(cl:in-package :hhgbot-augmented-assistant)
 
 ;; Special Variables

 (defparameter *zxcv* *standard-output*)

 (defvar *client*)

 (defvar *queue-pair* nil)

 ;; Macros
 

 (defun start-in-repl (&optional (start-bot t) (team-id :atomampd))

   (ubiquitous:restore :hhgbot-augmented-assistant)
   (setf slacker::*api-token* (ubiquitous:value :api-token :atomampd))
   (if start-bot

       (start-with-apitoken team-id)

       slacker::*api-token*))
 

 (defun start-with-apitoken (&optional (team-id :atomampd))

   (unless *queue-pair*
     (setf *queue-pair* (make-instance 'slacker::queue-pair)))
 

   (ubiquitous:restore :hhgbot-augmented-assistant)

   (let ((slacker::*api-token* (ubiquitous:value :api-token team-id)))

     (unless slacker::*api-token*
       (format *terminal-io* "~&API Token? ")
       (finish-output *terminal-io*)
       (setf slacker::*api-token* (read-line)))

     (values (slacker:coordinate-threads *queue-pair*)

 	    slacker::*api-token*)))

 
 (defmacro if-let* ((&rest bindings) &body (then-form &optional else-form))
   "Like if-let, but sets bindings sequentially.  Doesn't short-circuit."
   `(let* ,bindings
      (if (and ,@(mapcar #'car bindings))
        ,then-form
        ,else-form)))
 ;; Utility functions
 
 (define-command "myip" (event-pump ts channel)
   (in-wq (event-pump)
     (blackbird:alet ((ip (carrier:request "http://api.ipify.org/" :return-body t)))

       (format *zxcv* "~&IP: ~a~%TS: ~a~%CHANNEL: ~a~%CLIENT: ~A~%" (babel:octets-to-string ip) ts channel event-pump)

       (edit-message ts channel
 		    (concat "My ip is: "
 			    (babel:octets-to-string ip))))))
 
 (define-command "jira" (event-pump ts channel project &optional issue-number &rest rest)

   (let ((drakma:*drakma-default-external-format* :utf-8))
     (apply #'edit-message ts channel
 	   (fw.lu:ensure-list
 	    (cond (rest
 		   "I don't understand . . .")
 		  (issue-number
 		   (format nil "https://atomampd.atlassian.net/browse/~A-~A"
 			   project issue-number))
 		  (t
 		   (format nil "https://atomampd.atlassian.net/browse/ATOMOS-~a"
 			   project)))))))
 
 (define-command "pr" (event-pump ts channel num)
   (let ((num (parse-integer num)))
     (edit-message ts channel (format nil "https://bitbucket.org/atomampd/atomos/pull-requests/~d?w=1" num))))

 
 (define-command "js>" (event-pump ts channel &rest args)
   (declare (ignorable ts))
   (let ((*js-executor* (gethash :js-executor (modules event-pump))))
     (blackbird:alet ((result (submit-js *js-executor*
 					(string-join args " "))))
       (let ((result (cl-js:to-string result)))
 	(queue-message event-pump channel
 		       (subseq result 0
 			       (min 1000
 				    (length result)))
 		       :quote t)))))
 
 (define-command "my-rsa-key" (event-pump ts channel &optional (cipher "rsa"))
   (with-output-to-message (s event-pump  channel :quote t)
     (with-open-file (f (truename (concat "~/.ssh/id_" cipher ".pub"))) 
       (let ((seq (make-string (file-length f))))
 	(read-sequence seq f)
 	(format s seq)))))
 
 (define-command "paste" (event-pump ts channel)

   (with-simple-restart (abort "Stop command")
     (ubiquitous:restore :atomampd-slack)
     (format t "foo")
     (let ((drakma:*drakma-default-external-format* :utf-8))
       (edit-message ts channel
 		    (format nil "```~%~a~%```"
 			    (pop (ubiquitous:value :clip)))))))
 
 (define-command "id" (event-pump ts channel &optional (for "channel"))

   (edit-message ts channel

 		(string-case for
 		  ("channel" channel)
 		  (t (concat "don't know the id for " for)))))
     
 (defmacro with ((var val) &body body)
   `(let ((,var ,val))
      ,@body))
 
 (ql:quickload '(:vecto :ironclad))
 
 (defun hash-of-vector (vec)
   (ironclad:byte-array-to-hex-string (ironclad:digest-sequence :sha256 vec)))
 
 (defpackage #:vecto-example
   (:use :cl :alexandria :serapeum :slacker :vecto)
   (:shadowing-import-from :alexandria :rotate))
 

 (defparameter *zxcv* *standard-output*)
 
 (define-command "lss" (event-pump ts channel)
   (fw.lu:let-each (:be *)
     #p"~/public_html/Screenshots/"
     (uiop:directory-files *)
     (sort * #'> :key #'file-write-date)
     (car *)
     (uiop/common-lisp:enough-namestring * #p"~/public_html/")
     (concat "https://srv2.elangley.org/~edwlan/" *)
     (slacker.api:chat.post-message channel * :as_user t :icon_emoji "camera_with_flash")))
 

 (in-package :vecto-example)
 (defmacro with ((var val) &body body)
   `(let ((,var ,val))
      ,@body))
 
 
 (defun octets-to-36string (octets)
   (string-join (map 'list (lambda (it)
 			    (format nil "~2,1,0,'0@a"
 				    (with (*print-base* 36)
 				      (write-to-string it ))))
 		    octets)))
 
 (defmacro with-digested-output ((stream (data-sym digest-sym)) data-form &body body)
   (with-gensyms (digest-stream data-stream)
     `(let* ((,digest-stream (ironclad:make-digesting-stream :sha256))
 	    (,data-stream (ironclad:make-octet-output-stream))
 	    (,stream (make-broadcast-stream ,data-stream ,digest-stream)))
        ,data-form
        (let ((,data-sym (ironclad:get-output-stream-octets ,data-stream))
 	     (,digest-sym (ironclad:produce-digest ,digest-stream)))
 	 ,@body))))
 
 (define-command "ring-word" (event-pump ts channel &optional (content #(#x3BB)))
   (bt:make-thread
    (lambda ()
      (declare (optimize (debug 3)))

      (let ((*default-pathname-defaults* #p"/home/edwlan/github_repos/hhgbot/"))

        (with-canvas (:width 90 :height 90)
 	 (let ((font (get-font "times.ttf"))
 	       (step (/ pi 7)))
 	   (set-font font 40)
 	   (translate 45 45)
 	   (format hhgbot-augmented-assistant::*zxcv* "~&content: ~s~%" content)
 	   (draw-centered-string 0 -10 (map 'vector #'char-code content))
 	   (set-rgb-stroke 1 0 0)
 	   (centered-circle-path 0 0 35)
 	   (stroke)
 	   (set-rgba-stroke 0 0 1.0 0.5)
 	   (set-line-width 4)
 	   (dotimes (i 14)
 	     (with-graphics-state
 	       (vecto:rotate (* i step))
 	       (move-to 30 0)
 	       (line-to 40 0)
 	       (stroke))))
 	 (let* ((image-directory (ensure-directories-exist "/home/edwlan/public_html/slack_images/"))
 		(image-basename (concat channel "-" ts ".png"))
 		(image-filename (merge-pathnames image-basename image-directory))
 		(payload
 		 (concat "token=" *api-token*
 			 "&channel=" channel
 			 "&text=..." 
 			 "&as_user=true"
 			 "&attachments="
 			 (quri:url-encode
 			  (concat
 			   "[{\"fallback\": \"foo\", \"ts\":" ts ",\"image_url\": \"https://srv2.elangley.org/~edwlan/slack_images/"
 			   image-basename "\"}]")))))
 	   (vecto:save-png image-filename)
 	   (babel:octets-to-string
 	    (drakma:http-request "https://slack.com/api/chat.postMessage"
 				 :method :post
 				 :content payload))))))
      :name "Image Maker"))