(defpackage :fwoar.hub.client-sms
  (:use :cl :alexandria :fw.lu :fwoar.string-utils)
  (:export #:main #:queue-processor))
(in-package :fwoar.hub.client-sms)

(defparameter *obj-style* :hash-table)
(defparameter *event-table* (make-array 100 :adjustable t :fill-pointer 0))
(defparameter *event-queue* (lparallel.queue:make-queue))

(defun parse-fa-body (ht)
  (prog1 ht
    (ecase *obj-style*
      (:hash-table (setf (gethash "body" ht)
                         (yason:parse (gethash "body" ht)
                                      :object-as *obj-style*)))
      #+(or)
      (:alist (setf (assoc "body" ht)
                    (yason:parse (gethash "body" ht)
                                 :object-as *obj-style*))))))

(defun parse (string)
  (destructuring-bind (path result)
      (coerce (split #\space string
                     :count 1)
              'list)
    (format t "~&(PATH ~a) (RESULT ~a)~%"
            path result)
    (list path
          (parse-fa-body
           (yason:parse result
                        :object-as *obj-style*)))))

(defun get-and-process-one-message (socket)
  (let* ((raw-reply (pzmq:recv-string socket :encoding :utf-8)))
    (format t "~&~a~%" raw-reply)
    (destructuring-bind (path payload . r) (parse raw-reply)
      (when r
        (format t "~&extra stuff? PATH: ~a~%~4t~a~%~4t~a~2%"
                path
                payload
                r)) 
      payload)))

(defmacro with-hub ((symbol port subscription) &body body)
  (alexandria:once-only (port subscription)
    `(pzmq:with-socket ,symbol (:sub :subscribe ,subscription)
       (pzmq:connect ,symbol ,port)
       ,@body)))

(defun main-thread (&optional (subscription "/flowroutesms") (port "tcp://127.0.0.1:5557"))
  (format t "~&Starting main thread...~%")
  (pzmq:with-socket socket (:sub :subscribe subscription)
    (pzmq:connect socket port)
    (loop for i from 1
          for raw-reply = (pzmq:recv-string socket
                                            :encoding :utf-8)
          for (path payload . r) = (progn (format t "~&~a~%" raw-reply)
                                          (parse raw-reply))
          when r do (format t "~&extra stuff? PATH: ~a~%~4t~a~%~4t~a~2%"
                            path
                            payload
                            r)
            do (lparallel.queue:push-queue payload *event-queue*))))

(defun make-taskpaper (sms)
  (format nil "~{- ~a~%~}"
          (funcall (compose (op (remove-if (lambda (s) (equal s "")) _))
                            (op (map 'list #'serapeum:trim-whitespace _))
                            (op (fwoar.string-utils:split #\. _)))
                   (pick '("body" "body") sms))))

(defun get-filename (&optional (time (local-time:now)))
  (make-pathname :host "notes"
                 :directory "Listacular"
                 :name (local-time:format-timestring nil time
                                                     :format '("shopping-"
                                                               (:year 4) #\-
                                                               (:month 2) #\-
                                                               (:day 2)))
                 :type "taskpaper"))

(defun write-to-list (event)
  (with-output-to-file (f (get-filename) :if-exists :append :if-does-not-exist :create)
    (write-sequence (make-taskpaper event)
                    f)
    (finish-output f)))

(defun make-text-message (message)
  (lambda (stream)
    (yason:encode-alist (acons "body" message
                               '(("to" . "18325852660")
                                 ("from" . "18052103310")))
                        stream)))

(defun send-text-message (message)
  (let ((drakma:*text-content-types* (acons "application" "vnd.api+json"
                                            drakma:*text-content-types*)))
    (yason:parse
     (drakma:http-request "https://api.flowroute.com/v2/messages"
                          :basic-authorization (car
                                                (uiop:read-file-form
                                                 (translate-logical-pathname "CONFIG:flowroute.sexp")))
                          :method :post
                          :content-type "application/json"
                          :content (make-text-message message)))))

(defun finish-tasklist ()
  (let* ((taskfile (get-filename))
         (filename (pathname-name taskfile)))
    (if (probe-file taskfile)
        (loop for x from 1
              for version = (make-pathname :name (format nil "~a-v~d" filename x)
                                           :defaults taskfile)
              while (probe-file version)
              finally
                 (format *standard-output* "~&Renaming old taskfile ~a -> ~a~%"
                         taskfile
                         version)
                 (send-text-message
                  (format nil "~&Renaming old taskfile ~a -> ~a~%"
                          taskfile
                          version))
                 (rename-file taskfile version)
                 (return version))
        (format *standard-output* "~&No tasklist~%"))))

(defun test-get-filename ()
  (format *standard-output* "~&Test simple output: ~:[Fail~;Pass~]~%"
          (equal #p"notes:listacular;shopping-2017-02-02.taskpaper"
                 (get-filename (local-time:encode-timestamp 0 0 0 0 2 2 2017))))
  (format *standard-output* "~&Test that we ignore the time part of the timestamp: ~:[Fail~;Pass~]~%"
          (equal #p"notes:listacular;shopping-2017-02-02.taskpaper"
                 (get-filename (local-time:encode-timestamp 1 2 3 4 2 2 2017)))))

(defun queue-processor ()
  (format t "~&Starting queue processor...~%")
  (loop
    for ev = (lparallel.queue:pop-queue *event-queue*)
    for message-body = (pick '("body" "body")
                             ev)
    do
       (format t "~&New Message:~%~4tFrom: ~a~%~4tBody: ~a~2%"
               (pick '("body" "from") ev)
               message-body)
       (string-case:string-case ((string-trim " " (string-downcase message-body)))
         ("finish" (finish-tasklist))
         (t (write-to-list ev)))
       (sleep 0.01)))

(defun config-file-name (id)
  (merge-pathnames (make-pathname :host "CONFIG"
                                  :name (string-upcase id)
                                  :type "SEXP"
                                  :directory "")))

(defun config-for (id)
  (uiop:read-file-form (config-file-name id)))

(defun main ()
  "Note this depends on having setup
load-logical-pathname-translations appropriately for your
implementation"
  (load-logical-pathname-translations "NOTES")
  (load-logical-pathname-translations "CONFIG")
  (let ((main-thread (bt:make-thread #'main-thread
                                     :name "message-handler"
                                     :initial-bindings `((*event-queue* . ,*event-queue*)))))
    (queue-processor)))