; not a bool
(defn not (x) (if x nil #t))

(defn is-pos? (n) (> n nil))
(defn is-neg? (n) (< n nil))

(defn neg (n) (- 0 n))
(defn dec (n) (- n 1))
(defn inc (n) (+ n 1))


(defn string-ltrim (str) 
    (string-rltrim str " \n\r\t" "ltrim"))
(defn string-rtrim (str) 
    (string-rltrim str " \n\r\t" "rtrim"))
(defn string-trim (str) 
    (string-rltrim str " \n\r\t" "trim"))

(defn string-rpad (str length pad_char)
    (string-pad str length pad_char "rpad"))
(defn string-lpad (str length pad_char)
    (string-pad str length pad_char "lpad"))

(defn string-upcase (str) 
    (string-case str "upper"))
(defn string-downcase (str) 
    (string-case str "lower"))


(defn string-join (lst sep)
(do
	(def rslt "")
	(def i 0)
	(for e lst
        (if (= i 0)
			(do (def rslt (display e)) (def i 1))
			(def rslt (+ rslt (display sep) (display e)))
            ))
	rslt
	))

(defn itok (ascii) (sprintf "%c" (list ascii)))
(defn ktoi (char) (int (sprintf "%d" (list char))))

; pause for interval of seconds
(defn sleep (time) 
  (system-cmd (+ "sleep " (string time))))

(defn get-env (var) 
    (second (system-cmd (+ "echo ${" var "} | tr -d \"\n\""))))


(defn third (l) (index l 2))
(defn fourth (l) (index l 3))
(defn fifth (l) (index l 4))
(defn sixth (l) (index l 5))
(defn seventh (l) (index l 6))
(defn eight (l) (index l 7))
(defn nineth (l) (index l 8))
(defn tenth (l) (index l 9))
(defn nth (i l) (index l (- i 1)))

; return 1 when list contains item otherwise nil
(defn member (lst itm) 
    (do
        ; TODO check if is empty list
        (def found_index -1)
        (def i 0)
        (def lst_len (len lst))

        (while (and (< i lst_len) (= found_index -1))
            (if (= itm (index lst i))
                (set! found_index i)
                (set! i (+ i 1))
                ))

        (if (!= -1 found_index)
            #t
            nil)
    ))

(defn make-list-of (size val)
    (do
        (def lst '())
        (def i 0)
        (while (< i size)
            (def lst (push lst val))
            (def i (inc i)))
        lst
    ))

(defn make-list (size)
    (make-list-of size nil))

(defn empty-list? (lst) (and (= (type lst) "list") (= (len lst) 0)))

(defn uniq (lst)
    (do
        (def rslt '())    
        (def i 0)
        (def lst_len (len lst))
        (while (< i lst_len)
            (def e (index lst i))
            (if (not (member rslt e)) 
                (def rslt (push rslt e)))

                (def i (inc i)))                

        rslt
    ))

(defn flatten (lst)
    (do 
        (def rslt '())
        (for e lst
            (if (= (type e) "list")
                (do 
                    (for ee (flatten e)
                        (def rslt (push rslt ee))))
                (def rslt (push rslt e))
            ))
        rslt
    ))

(defn take (lst n)
	(if (> (len lst) n)
		(map (lambda (i) (index lst i)) (range 0 n))
		lst))
    
(defn quick-sort-by (l cmp)
    (if (<= (len l) 1)
        l
        (do
            (def pivot (first l))
            (+
                (quick-sort-by (filter (lambda (n) (cmp pivot n)) l) cmp)
                (list pivot)
                (quick-sort-by (tail (filter (lambda (n) (not (cmp pivot n))) l)) cmp)
            ))
    ))

(defn quick-sort (l)
    (quick-sort-by l (lambda (a b) (> a b))))

(defn quick-sort-reverse (l)
    (quick-sort-by l (lambda (a b) (> b a))))


(defn start-of-day (datetime) (str-to-date (+ (date-to-str datetime "%Y-%m-%d") " " "00:00:00") "%Y-%m-%d %H:%M:%S"))
(defn end-of-day (datetime) (str-to-date (+ (date-to-str datetime "%Y-%m-%d") " " "23:59:59") "%Y-%m-%d %H:%M:%S"))
(defn start-of-month (datetime) (str-to-date (+ (date-to-str datetime "%Y-%m") "-01 00:00:00") "%Y-%m-%d %H:%M:%S"))
(defn start-of-next-month (datetime) (date-add (start-of-month datetime) 1 "month"))
(defn end-of-next-month (datetime) (date-add (end-of-month datetime) 1 "month"))
(defn end-of-month (datetime) (date-add (date-add (start-of-month datetime) 1 "month") -1 "second"))
(defn start-of-prev-month (datetime) (date-add (start-of-month datetime) -1 "month"))
(defn end-of-prev-month (datetime) (date-add (end-of-month datetime) -1 "month"))
(defn start-of-year (datetime) (str-to-date (+ (date-to-str datetime "%Y") "-01-01 00:00:00") "%Y-%m-%d %H:%M:%S"))
(defn end-of-year (datetime) (str-to-date (+ (date-to-str datetime "%Y") "-12-31 23:59:59") "%Y-%m-%d %H:%M:%S"))


; from list of lists creates csv string
; (print (make-csv '(("r1c1" "r1c2") ("r2c1" "r2c2"))))
(defn make-csv (csv_list)
    (do
        (def rows_str "")
        (def r 0)
        (for row csv_list
            (def cols_str "")
            (def c 0)
            (for col row
                (if (= c 0)
                    (def cols_str col)
                    (def cols_str (+ cols_str "," (display col)))) 
                (def c (inc c)))
            (if (= r 0)
                (def rows_str cols_str)
                (def rows_str (+ rows_str "\n" cols_str))) 
            (def r (inc r)))

        rows_str
    ))


; looks into lst's elements and when there is a list with first item with name, it returns the _second_ element of that list 
(defn find-val-in-list (lst name)
  (do 
	(def found_val nil)
	(def i 0)

	(def list_len (len lst))
	(while (and (>= i 0) (< i list_len))
	  (def e (index lst i))
	  (set! i (inc i))
	  (if  (= (type e) "list")
		(if  (= (type (first e)) "list")
		  (do 	(set! found_val (find-val-in-list (first e) name))
			(if (!= found_val nil) (set! i -1))
		  )
		  ; else
		  (do
			(if (= name (first e)) 
				(do 
				  (set! found_val (second e)) (set! i -1)
				)
				; else
				(if (= (type (second e)) "list")
		  		    (do (set! found_val (find-val-in-list (second e) name)) 
			  		(if (!= found_val nil) 
					  (set! i -1)
					)
				    )
				)
		  	)
		  )
		)
	  )
	  ; else
	  (if (= name e) 
		(do (set! found_val (index lst (inc i))) (set! i -1))
	  )
	)
	found_val
  ))


(defn min (l)
    (if (or (not l) (= (len l) 0))
        nil
        (do
            (def minn (index l 0))
            (def i 1)
            (while (< i (len l))
                (if (< (index l i) minn)
                    (set! minn (index l i)))
                (set! i (inc i))
            )
            minn
        )
    ))

(defn max (l)
    (if (or (not l) (= (len l) 0))
        nil
        (do
            (def maxx (index l 0))
            (def i 1)            
            (while (< i (len l))
                (if (> (index l i) maxx)
                    (set! maxx (index l i)))
                (set! i (inc i))
            )
            maxx
        )
    ))

; load and init do system
(include "/usr/local/var/mlisp/doc.lsp")