:: Three ways we interactg with this app
:: 1. .^(%gx /=gh=/endpoint)
:: 2. [%peer [our %gh] /endpoint]
:: 3. :gh &gh-poke %post /gists json-data


::  This is a driver for the Github API v3.
::
::  You can interact with this in a few different ways:
::
::    - .^(%gx /=gh=/read{/endpoint}) or subscribe to
::      /scry/x/read{/endpoint} for authenticated reads.
::
::    - subscribe to /scry/x/listen/{owner}/{repo}/{events...}
::      for webhook-powered event notifications.  For event list,
::      see https://developer.github.com/webhooks/.
::
::  See the %github app for example usage.
::
/?  314
/+  http
::::
/=  rfc  /:  /%/rfc  /txt/
::
//  /%/split
::/-  gmail
::  /ape/gh/split.hoon defines ++split, which splits a request
::  at the end of the longest possible endpoint.
::

=>  |%                              :: => only used for indentation
    ++  move  (pair bone card)
    ++  subscription-result
      $%  [%arch arch]
          [%json json]      
          [%null ~]
      ==
    ++  card
      $%  [%diff subscription-result]
          [%hiss wire [~ ~] %httr [%hiss hiss]]
      ==
    --
::
|_  [hid=bowl count=@ web-hooks=(map ,@t ,[id=@t listeners=(set bone)])]

::  We can't actually give the response to pretty much anything
::  without blocking, so we just block unconditionally.
::
++  peek
  |=  [ren=@tas pax=path]
  ^-  (unit (unit (pair mark ,*)))
  ~
::
++  peer-scry
  |=  pax=path
  ^-  [(list move) _+>.$]
  ?>  ?=([care ^] pax)                ::  assert %u
  =>  (help i.pax i.t.pax t.t.pax)
  =>  scry
  %=  make-move
    count  +(count)
  ==
::
++  poke-gmail-req
  |=  [method=meth endpoint=path quy=quay]::jon=(unit json)]
  ^-  [(list move) _+>.$]
  ?>  ?=(valid-get-endpoint endpoint)
  :_  +>.$  :_  ~
  ^-  move
  :*  ost.hid  %hiss  /poke/[method]  `~  %httr  %hiss
      ^-  purl
      :+  [& ~ [%& /com/googleapis/www]]
        [~ gmail/v1/users/me/`valid-get-endpoint`endpoint]
      `quay`[[%alt %json] ~] 
  ::
      :+  method  `math`(mo ~[content-type/['application/json']~])
      =+  json-data=(joba %raw (jape (sifo (role rfc))))
      ~&  json-data
      =+  six-four=(tact (pojo json-data))
      ~&  sixf/six-four
      (some six-four)
      ::?~  jon  ~
      ::~&  (taco (crip (pojo u.jon)))
      ::(some (taco (crip (pojo u.jon))))                 ::  have to make it a unit again
  ==
::
::  HTTP response.  We make sure the response is good, then
::  produce the result (as JSON) to whoever sent the request.
::

++  sigh-httr
  |=  [wir=wire res=httr]
  ^-  [(list move) _+>.$]
  ~&  rfc/rfc
  ?.  ?=([care @ @ @ *] wir)
  ::  pokes don't return anything
  ~&  poke/res
    [~ +>.$]
  =+  arg=(path (cue (slav %uv i.t.t.wir)))
  :_  +>.$  :_  ~
  :+  ost.hid  %diff
  ?+  i.wir  null/~
      %x
    ?~  r.res
      json/(jobe err/s/%empty-response code/(jone p.res) ~)
    =+  jon=(rush q.u.r.res apex:poja)
    ?~  jon
      json/(jobe err/s/%bad-json code/(jone p.res) body/s/q.u.r.res ~)
    ?.  =(2 (div p.res 100))
      json/(jobe err/s/%request-rejected code/(jone p.res) msg/u.jon ~)
    ::
    ::  Once we know we have good data, we drill into the JSON
    ::  to find the specific piece of data referred to by 'arg'
    ::
  |-  ^-  subscription-result
  ?~  arg
   [%json `json`u.jon]
  =+  dir=((om:jo some) u.jon)
  ?~  dir  json/(jobe err/s/%no-children ~)
  =+  new-jon=(~(get by u.dir) i.arg)
  `subscription-result`$(arg t.arg, u.jon ?~(new-jon ~ u.new-jon))
           ::  redo with next argument
  ::
    %y
  ?~  r.res 
    ~&  [err/s/%empty-response code/(jone p.res)]
      arch/*arch
  =+  jon=(rush q.u.r.res apex:poja)
  ?~  jon
    ~&  [err/s/%bad-json code/(jone p.res) body/s/q.u.r.res]
    arch/*arch
  ?.  =(2 (div p.res 100))
    ~&  [err/s/%request-rejected code/(jone p.res) msg/u.jon]
    arch/*arch
    ::
    ::  Once we know we have good data, we drill into the JSON
    ::  to find the specific piece of data referred to by 'arg'
    ::
    |-  ^-  subscription-result
    =+  dir=((om:jo some) u.jon)
    ?~  dir
      [%arch `(shax (jam u.jon)) ~]
    ?~  arg
      [%arch `(shax (jam u.jon)) (~(run by u.dir) ,~)]
    =+  new-jon=(~(get by u.dir) i.arg)
    $(arg t.arg, u.jon ?~(new-jon ~ u.new-jon))
  ==

++  sigh
  |=  a=*
  ~&  a/a
  :_  +>.$  ~
::
++  help
  |=  [ren=care style=@tas pax=path]
  ~&  pax
  =^  query  pax
    =+  xap=(flop pax)
    ?~  xap  [~ ~]
    =+  query=(rush i.xap ;~(pfix wut yquy:urlp))
    ?~  query  [~ pax]
    [u.query (flop t.xap)]
  =^  arg  pax  [+ -]:(split pax)
  ~&  [pax=pax arg=arg query=query]
  =|  mow=(list move)
  |%
  ::  Resolve core
  ::
  ++  make-move
    ^-  [(list move) _+>.$]
    [(flop mow) +>.$]
    ::
  ++  endpoint-to-purl
    |=  endpoint=path
   ^-  purl
    %+  scan 
      "https://www.googleapis.com/gmail/v1/users/me{<`path`endpoint>}"
    auri:epur
    ::  Send an HTTP req
  ++  send-http
    |=  hiz=hiss
    ^+  +>
    =+  wir=`wire`[ren (scot %ud count) (scot %uv (jam arg)) style pax]
    =+  new-move=[ost.hid %hiss wir `~ %httr [%hiss hiz]]
    +>.$(mow [new-move mow])
  ::
  ++  scry
    ^+  .
    ?+  style  ~|(%invalid-style !!)
      %read   read
::        %listen listen
    ==
  :: Standard GET request
  ++  read  (send-http (endpoint-to-purl pax) %get ~ ~)
  
  ::  Subscription request
::    ++  listen
::      ^+  .
::      =+  events=?>(?=([@ @ *] pax) t.t.pax)
::      |-  ^+  +>.$
::      ?~  events
::        +>.$
::      ?:  (~(has by web-hooks) i.events)                ::  if hook exists
::        =.  +>.$  (update-hook i.events) 
::        $(events t.events)
::      =.  +>.$  (create-hook i.events)
::      $(events t.events)
    ::
  --
--