(in-package #:tempores.parser)

;; This will help make sure everything is consumed when
;; we don't care about the parser's output.

(defun cdar-equal (a b) (== (cdar a) (cdar b)))

(st:deftest time-line-test ()
  (st:should be cdar-equal '(("   start@" . ""))
             (run (.time-line-start) "   start@"))
  (st:should be == '(((((0 0 0))) . ""))
             (run (.time-line) (format nil "   start@00:00:00--~%")))
  (st:should be == '(((((0 0 0) (1 0 0))) . ""))
             (run (.time-line) (format nil "   start@00:00:00--01:00:00~%")))
  (st:should be == '(((((0 0 0) (1 0 0))
                       ((2 0 0)))
                      . ""))
             (run (.time-line) (format nil "   start@00:00:00--01:00:00,02:00:00--~%")))
  (st:should be == '(((((0 0 0) (1 0 0))
                       ((2 0 0) (3 0 0)))
                      . ""))
             (run (.time-line) (format nil "   start@00:00:00--01:00:00,02:00:00--03:00:00~%")))
  (st:should be == '(((((0 0 0) (1 0 0))
                       ((2 0 0)))
                      . ""))
             (run (.time-line) (format nil "   start@00:00:00--01:00:00, 02:00:00--~%"))))

(st:deftest range-list-test ()
  (st:should be == '((#\, . ""))
             (run (.range-list-separator) ","))
  (st:should signal invalid-time
             (run (.range-list) "30:00:00"))
  (st:should be == nil
             (run (.range-list) "00:00:00"))
  (st:should be == nil
             (run (.range-list) "00:00:00--,00:00:00"))
  (st:should be == '(((((0 0 0))) . ""))
             (run (.range-list) (format nil "00:00:00--~%")))
  (st:should be == '(((((0 0 0) (1 0 0))) . ""))
             (run (.range-list) (format nil "00:00:00--01:00:00~%")))
  (st:should be == '(((((0 0 0) (1 0 0))
                       ((2 0 0)))
                      . ""))
             (run (.range-list) (format nil "00:00:00--01:00:00,02:00:00--~%")))
  (st:should be == '(((((0 0 0) (1 0 0))
                       ((2 0 0) (3 0 0)))
                      . ""))
             (run (.range-list) (format nil "00:00:00--01:00:00,02:00:00--03:00:00~%")))
  (st:should be == `(((((0 0 0) (1 0 0) ,(make-time-mod -10 "mins"))
                       ((2 0 0) (3 0 0))
                       )
                      . ""))
             (run (.range-list) (format nil "00:00:00--01:00:00-10mins,02:00:00--03:00:00~%")))
  (st:should be == `(((((0 0 0) (1 0 0) ,(make-time-mod 10 "mins"))
                       ((2 0 0) (3 0 0))
                       )
                      . ""))
             (run (.range-list) (format nil "00:00:00--01:00:00+10mins,02:00:00--03:00:00~%")))
  (st:should be == '(((((0 0 0) (1 0 0))
                       ((2 0 0)))
                      . ""))
             (run (.range-list) (format nil "00:00:00--01:00:00, 02:00:00--~%")))) ;; space allowed between ranges

(st:deftest time-test ()
  (st:should signal invalid-time
             (run (.time) "00:0a:00"))
  (st:should be == '(((0 0 0) . ""))
             (handler-bind ((invalid-time
                              (lambda (x) x
                                (smug:replace-invalid "00:0a:00" "00:00:00"))))
               (run (.time) "00:0a:00")))
  (st:should be == '((#\: . ""))
             (run (.time-separator) ":"))
  (st:should signal invalid-time
             (run (.time) "30:00:00"))
  (st:should be == '(((0 0 0) . ""))
             (run (.time) "00:00:00")))

(st:deftest digit-test ()
  (loop for char in '(#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
        do (st:should be == `((,char . ""))
                      (run (.digit) (make-string 1 :initial-element char)))) )

(st:deftest minute-test ()
  (st:should be == nil
             (run (.first-minute-char) "a"))
  (st:should be == nil
             (run (.first-minute-char) "6"))
  (st:should be == nil
             (run (.first-minute-char) "-1"))
  (loop for char in '(#\0 #\1 #\2 #\3 #\4 #\5)
        do (st:should be == `((,char . ""))
                      (run (.first-minute-char) (make-string 1 :initial-element char))))
  (st:should be == nil
             (run (.minute-or-second) "61"))
  (st:should be == nil
             (run (.minute-or-second) "71"))
  (st:should be == nil
             (run (.minute-or-second) "0"))  ;; one digit
  (st:should be == nil
             (run (.minute-or-second) "aa"))
  (st:should be == `(("01" . ""))
             (run (.minute-or-second) "01")))

(st:deftest hour-test ()
  (st:should be == nil
             (run (.first-hour-char) "a"))
  (st:should be == nil
             (run (.first-hour-char) "3"))
  (st:should be == nil
             (run (.first-hour-char) "-1"))
  (st:should be eq T
             (every #'identity
                    (loop for char in '(#\0 #\1 #\2)
                          collect (== `((,char . ""))
                                      (run (.first-hour-char) (make-string 1 :initial-element char))))))
  (st:should be == nil
             (run (.hour) "24"))
  (st:should be == nil
             (run (.hour) "71"))
  (st:should be == nil
             (run (.hour) "0"))
  (st:should be == nil
             (run (.hour) "aa"))
  (st:should be == `(("20" . ""))
             (run (.prog1 (.hour) (.not (.item))) "20"))
  (st:should be == `(("01" . ""))
             (run (.prog1 (.hour) (.not (.item))) "01")))

(st:deftest month-test ()
  (st:should be == nil
             (run (.first-month-char) "a"))
  (st:should be == nil
             (run (.first-month-char) "4"))
  (st:should be == nil
             (run (.first-month-char) "-1"))
  (loop for char in '(#\0 #\1 #\2 #\3)
        do (st:should be == `((,char . ""))
                      (run (.first-month-char) (make-string 1 :initial-element char))))
  (st:should be == nil
             (run (.month) "32"))
  (st:should be == nil
             (run (.month) "71"))
  (st:should be == nil
             (run (.month) "0"))
  (st:should be == nil
             (run (.month) "aa"))
  (st:should be == `(("30" . ""))
             (run (.prog1 (.month) (.not (.item))) "30"))
  (st:should be == `(("20" . ""))
             (run (.prog1 (.month) (.not (.item))) "20"))
  (st:should be == `(("10" . ""))
             (run (.prog1 (.month) (.not (.item))) "10"))
  (st:should be == `(("01" . ""))
             (run (.prog1 (.month) (.not (.item))) "01")))

(st:deftest time-range-test ()
  (st:should be == '(("--" . ""))
             (run (.time-range-separator) "--"))
  (st:should be == nil
             (run (.time-range) "30:00:00"))
  (st:should be == nil
             (run (.time-range) "00:00:00"))
  (st:should be == nil
             (run (.time-range) "00:00:00--,01:00:00--"))
  (st:should be == '((((0 0 0)) . ""))
             (run (.time-range) "00:00:00--"))
  (st:should be == '((((0 0 0) (1 0 0)) . ""))
             (run (.time-range) "00:00:00--01:00:00")) 

  (st:should be == nil
             (run (.time-range) "00:00:00"))
  (st:should be == `(( (,(make-time-obj 0 0 0)) . ""))
             (run (.time-range) "00:00:00--"))
  (st:should be == `(( (,(make-time-obj 0 0 0)) . ""))
             (run (.time-range) "00:00--"))
  (st:should be == `(((,(make-time-obj 0 0 0) ,(make-time-obj 1 0 0)) . ""))
             (run (.time-range) "00:00:00--01:00:00"))
  (st:should be == `(((,(make-time-obj 0 0 0) ,(make-time-obj 1 0 0)) . ""))
             (run (.time-range) "00:00--01:00"))
  (st:should be == `(((,(make-time-obj 0 0 0) ,(make-time-obj 1 0 0) ,(make-time-mod 10 "mins")) . ""))
             (run (.time-range) "00:00--01:00+10mins"))
  (st:should be == `(((,(make-time-obj 0 0 0) ,(make-time-obj 1 0 0) ,(make-time-mod -10 "mins")) . ""))
             (run (.time-range) "00:00--01:00-10mins")))

(st:deftest memo-test ()
  (st:should be == '(("asdf" . ""))
             (run (.client-name) "asdf:"))
  (st:should be == '(("asdf" . ""))
             (run (.memo) (format nil " asdf")))
  (st:should be == '((("asdf" "asdf") . ""))
             (run (.memo-line) (format nil "   asdf: asdf"))))

(st:deftest initial-space-test ()
  (st:should signal invalid-whitespace
             (smug:parse (.initial-space) "    "))
  (st:should signal invalid-whitespace
             (smug:parse (.initial-space) (concatenate 'string
                                                       (string #\tab)
                                                       " ")))
  (st:should signal invalid-whitespace
             (smug:parse (.initial-space) (concatenate 'string
                                                       (string #\tab)
                                                       (string #\tab))))
  (st:should signal invalid-whitespace
             (smug:parse (.initial-space) (concatenate 'string
                                                       (string #\tab)
                                                       "      ")))
  (st:should be == (string #\tab)
             (smug:parse (.initial-space) (string #\tab)))
  (st:should be == "   "
             (smug:parse (.initial-space) "   ")))

(st:deftest make-time-mod-test ()
  (st:should be ==
             (make-instance 'time-mod :unit :hour :amount 0) 
             (make-time-mod 0 "hours"))

  (st:should be ==
             (make-time-mod 0 "hours")
             (make-time-mod 0 "hours"))

  (st:should be ==
             (make-time-mod 0 "hr")
             (make-time-mod 0 "hours"))

  (st:should be ==
             (make-time-mod 0 "hrs")
             (make-time-mod 0 "hours"))

  (st:should be ==
             (make-time-mod 0 "min")
             (make-time-mod 0 "minutes"))

  (st:should be ==
             (make-time-mod 0 "mins")
             (make-time-mod 0 "minutes")))

(st:deftest date-test ()
  (st:should be == nil
             (caar (smug:run (.date) "Monday 2020/01-01")))
  (st:should be == (make-date-obj "Monday" 2020 01 01)
             (caar (smug:run (.date) "Monday, 2020-01-01")))
  (st:should be == (make-date-obj "Monday" 2020 01 01)
             (caar (smug:run (.date) "Monday 2020-01-01")))
  (st:should be == (make-date-obj "Monday" 2020 01 01)
             (caar (smug:run (.date) "Monday 2020/01/01"))))

(st:deftest generic-eq-test ()
  "Note: this really should be in the equality package with the name ==
   should-test only checks tests for _internal_ symbols."
  (st:should be eql t (== #\1 #\1))
  (st:should be eql t (== 1 1))
  (st:should be eql t (== "1" "1"))
  (st:should be eql t (== '("1") '("1")))
  (st:should be eql t (== #("1") #("1")))
  (st:should be eql t (== '(1 . 2) '(1 . 2)))
  (st:should be eql t (== '((1 . 2)) '((1 . 2))))
  (st:should be eql t (== #1=(make-date-obj "Monday" 2020 01 01) #1#))
  (st:should be eql t
             (== (make-date-obj "Monday" 2012 01 01)
                 (make-date-obj "Monday" 2012 01 01)))
  (st:should be eql t
             (== (make-time-obj 00 00 00)
                 (make-time-obj 00 00 00)))
  (st:should be eql t
             (== (make-time-mod 3 "mins")
                 (make-time-mod 3 "mins")))
  (st:should be eql t
             (== (list (make-time-mod 3 "mins"))
                 (list (make-time-mod 3 "mins"))))
  (st:should be eql t
             (== #((make-time-mod 3 "mins"))
                 #((make-time-mod 3 "mins")))))