(in-package :slacker)

(defun slack-api-call (method &rest args)
  (bb:with-promise (resolve reject)
    (bt:make-thread
     (lambda ()
       (handler-case
           (let ((api-result (yason:parse
                              (babel:octets-to-string 
                               (drakma:http-request (concat "https://slack.com/api/" method "?token="
                                                            *api-token*)
                                                    :method :post
                                                    :content (quri:url-encode-params
                                                              (loop for (key value) on args by #'cddr
                                                                    collect (cons
                                                                             (string-downcase key)
                                                                             value))))))))
             ;; todo error handling . . .
             (resolve api-result)) 
         (serious-condition (c)
           (format t "~&Received condition ~s~%" c)
           (reject c)))))))

(defmacro define-api-wrapper (name required-args &rest args)
  (flet ((name-case (string)
           (let ((parts (split-sequence #\- (string-downcase string))))
             (apply #'concatenate 'string
                    (car parts)
                    (mapcar #'string-capitalize (cdr parts))))))
    (let* ((api-method-name (name-case name)))
      `(progn (defun ,name (,@required-args &rest r &key ,@args)
                (apply #'slack-api-call ,api-method-name
                       ,@(loop for req-arg in required-args
                               append (list (make-keyword req-arg) req-arg))
                       r))
              (eval-when (:compile-toplevel :load-toplevel :execute)
                (let ((*package* (find-package 'slacker.api)))
                  (import ',name)
                  (export ',name)))))))

(defmacro define-api-wrappers (&body body)
  `(progn ,@(loop for (name required-args . rest) in body
                  collect `(define-api-wrapper ,name ,required-args ,@rest))))

(in-package :slacker.api)

(slacker::define-api-wrappers
  (auth.test ())
  (users.list () include_locale limit cursor)
  (channels.list () exclude_archived)
  (conversations.list () exclude_archived types)
  (conversations.join (channel)) 
  (chat.delete (ts channel) as_user)
  (chat.me-message (channel text))
  (chat.post-message (channel text)
                     parse link_name attachments unfurl_links unfurl_media username as_user
                     icon_uri icon_emoji)
  (chat.update (ts channel text) attachments parse link_names as_user))