(defpackage :fwoar.graphql
   (:import-from :data-lens :key :over :juxt)
   (:import-from :serapeum :defalias)
   (:use :cl )
   (:export ))
 (in-package :fwoar.graphql)
 
 #|
 ;; query {
 ;;   search(query: "topic:common-lisp", type: REPOSITORY, first: 100) {
 ;;     edges {
 ;;       node {
 ;;         ... on Repository {
 ;;           owner {
 ;;             login
 ;;           }
 ;;           name
 ;;           description 
 ;;           pushedAt
 ;;         }
 ;;       }
 ;;     }
 ;;   }
 ;; }
 |#
 
 (defun camelize (name)
   (fw.lu:with (parts (fwoar.string-utils:split #\- (string-downcase name)))
     (format nil "~a~{~:(~a~)~}"
             (elt parts 0)
             (map 'list #'string-capitalize (subseq parts 1)))))
 
 (defun handle-term (term)
   (typecase term
     (symbol (camelize term))
     (t term)))
 
 (defun sexp->query (s expr)
   (destructuring-bind (op &rest body) expr
     (pprint-logical-block (s nil)
       (pprint-logical-block (s nil)
         (pprint-indent :block 4 s)
         (if (listp op)
             (format s "~a(~{~a~^, ~})"
                     (handle-term (car op))
                     (loop for (key value) on (cdr op) by #'cddr
                           collect (format nil "~a:~a" (handle-term key) value)))
             (princ (handle-term op) s))
         (princ " {" s)
         (loop for expr in body
               do
                  (pprint-newline :mandatory s)
               if (listp expr) do
                 (sexp->query s expr)
               else do
                 (princ (handle-term expr)
                        s)))
       (pprint-newline :mandatory s)
       (format s "}"))))
 
 (defun dive (&rest keys)
   (lambda (map)
     (declare (dynamic-extent map))
     (fw.lu:dive keys map)))
 
 (defalias <>
   'alexandria:compose)
 
 (defun %jq (&rest query)
   (lambda (map)
     (reduce (lambda (acc next)
               (typecase next
                 (list (ecase (car next)
                         (:juxt (funcall (apply 'juxt
                                                (mapcar '%jq
                                                        (cdr next)))
                                         acc))
                         (:dive (funcall (apply '%jq (cdr next))
                                         acc))
                         (:map (funcall (over (apply '%jq (cdr next)))
                                        acc))))
                 (t (gethash next acc))))
             query
             :initial-value map)))
 
 (defmacro jq (&rest query)
   `(%jq ,@(mapcar (lambda (v) `',v)
                   query)))
 
 (defun format-results (results)
   (format t "~:{* ~a/~a ~a~%~2t~a~%~%~}"
           results))
 
 
 ;; .data.search.edges[]
 ;; | .node
 ;; | "* "+ .owner.login + "/" + .name + " " + .pushedAt + "\n  " + .description + "\n"'
 
 (defalias extract-data
   (jq "data"
       "search"
       "edges"
       (:map "node"
             (:juxt (:dive "owner"
                           "login")
                    "name"
                    "pushedAt"
                    "description"))))
 
 (defun search-for-topic-repos (topic)
   `(query ((search query ,(format nil "\"topic:~a\"" topic)
                    type "REPOSITORY"
                    first "100")
            (edges
             (node
              ("... on Repository"
               (owner login)
               name
               description
               pushed-at))))))
 
 (defun github-graphql (token query)
   (let ((drakma:*text-content-types* (acons "application" "json"
                                             drakma:*text-content-types*)))
     (yason:parse (drakma:http-request "https://api.github.com/graphql"
                                       :method :post 
                                       :content   (yason:with-output-to-string* ()
                                                    (yason:with-object ()
                                                      (yason:encode-object-element
                                                       "query"
                                                       (with-output-to-string (s)
                                                         (sexp->query s query)))))
                                       :additional-headers `(("Authorization" . ,(format nil "bearer ~a" token)))))))