lsp

#!/usr/bin/env elvish
use file
use str
use path

# pipe between input thread(writer), file tracking thread(writer) and server thread(reader)
var p = (file:pipe)

var content = (put [&jsonrpc=2.0 &id=(num 1) &method=initialize &params=[
  &rootUri=file://$pwd
  &processId=(num $pid)
  &capabilities=[
    &general=[
      &positionEncodings=[utf-8]
    ]
    &textDocument=[
      &publishDiagnostics=[&]
    ]
  ]
]] | to-json)
put "-------------> main thread send: "$content
printf "Content-Length: %d\r\n\r\n%s" (count $content) $content > $p
set content = (put [&jsonrpc=2.0 &method=initialized &params=[&]] | to-json)
put "-------------> main thread send: "$content
printf "Content-Length: %d\r\n\r\n%s" (count $content) $content > $p

var mnt = '/tmp/acme'
var winid
var winname = (echo $pwd | 9 tr .@ _)/+LSP
var opens = [&]

fn checkwin {
  try {
    var @parts = (str:fields (9p read acme/index | grep -e $winname))
    set winid = $parts[0]
  } catch e {
    # window not exist, just create one
    set winid = (str:fields (9p read acme/new/ctl) | take 1)
    echo 'name '$winname | 9p write acme/$winid/ctl
    echo 'add_env lsp_root='$pwd | 9p write acme/$winid/ctl
    # close current window when tmux session exits.
    tmux set-hook -p 'alert-silence['$winid']' 'run "echo delete | 9p write acme/'$winid'/ctl > /dev/null || true"'
  }
}

fn append {|s|
  echo $s | 9p write acme/$winid/body
  echo clean | 9p write acme/$winid/ctl
}

fn endoffset {
  var f = (file:open-output &also-input=$true &if-not-exists=error &if-exists=update $mnt/$winid/addr)
  print '$' > $f
  var @parts = (str:fields (cat < $f))
  put $parts[1]
  file:close $f
}

fn show {|begin end|
  print '#'$begin,'#'$end | 9p write acme/$winid/addr
  echo dot=addr | 9p write acme/$winid/ctl
  echo show | 9p write acme/$winid/ctl
}

fn read_line {|f l|
  var @lines = (cat $f | from-lines)
  put $lines[$l]
}

var log = (file:open $mnt/log)
var id = (num 1)
var cbs = [&]
run-parallel {
  # server thread
  eval (str:join ' ' $args) < $p | while $true {
    var m
    try {
      var n = (read-upto "\n")[16..-2] # get content length
      read-upto "\n" | nop # skip "\r\n"
      set m = (echo (read-bytes $n) | from-json)
    } catch e {
      put 'server thread error:'
      pprint $e
      put 'server thread exit'
      file:close $p[r]
      break
    }

    try {
      if (and (has-key $m method) (==s $m[method] textDocument/publishDiagnostics)) {
        if (not (eq $m[params][diagnostics] [])) {
          var file = $m[params][uri][7..] # skip "file://"
          var cur_file = (str:fields (9p read acme/(9 dial unix!(9 namespace)/acmefocused)/tag) | take 1)
          if (==s $file $cur_file) {
            var begin = (endoffset)
            for entry $m[params][diagnostics] {
              var msg = (printf "%s:%d+#%d,%d+#%d: %s" $file^
                $entry[range][start][line] $entry[range][start][character]^
                $entry[range][end][line] $entry[range][end][character]^
                $entry[message] | slurp)
              append $msg
            }
            show $begin (endoffset)
          }
        }
      } else {
        $cbs[$m[id]] $m[result]
        del cbs[$m[id]]
      }
    } catch e {
      pprint $m
    }
  }
} {
  # file tracking thread
  var content
  fn handle {|winid cmd @rest|

    # skip if there's no file path
    if (eq $rest []) {
      return
    }
    var name = $rest[0]
    # skip non-regular file
    # TODO: symlink?
    if (not (path:is-regular $name)) {
      return
    }

    if (and (==s del $cmd) (has-key $opens $name)) {
      set content = (put [&jsonrpc=2.0 &method=textDocument/didClose &params=[
        &textDocument=[
          &uri=file://$name
        ]
      ]] | to-json)

      put "-------------> file tracking thread send: "$content
      printf "Content-Length: %d\r\n\r\n%s" (count $content) $content > $p

      del opens[$name]
      tmux set-hook -pu 'alert-silence['$winid']'
    } elif (and (==s put $cmd) (has-key $opens $name)) {
      set content = (put [&jsonrpc=2.0 &method=textDocument/didChange &params=[
        &textDocument=[
          &uri=file://$name
          &version=(num 0)
        ]
        &contentChanges=[[&text=(9p read acme/$winid/body | slurp)]]
      ]] | to-json)

      put "-------------> file tracking thread send: "$content
      printf "Content-Length: %d\r\n\r\n%s" (count $content) $content > $p

      set content = (put [&jsonrpc=2.0 &method=textDocument/didSave &params=[
        &textDocument=[
          &uri=file://$name
        ]
      ]] | to-json)

      put "-------------> file tracking thread send: "$content
      printf "Content-Length: %d\r\n\r\n%s" (count $content) $content > $p

      if (eq $E:_lsp_format_on_save 1) {
        set id = (+ $id 1)
        # register a edit callback
        set cbs[$id] = {|m|
          var f = (file:open-output &if-not-exists=error &if-exists=update $mnt/$winid/addr)
          defer {
            file:close $f
          }

          fn apply {|m|
            printf '%d+#%d,%d+#%d'^
              $m[range][start][line] $m[range][start][character]^
              $m[range][end][line] $m[range][end][character]^
            > $f
            print $m[newText] | 9p write acme/$winid/data
          }

          if (==s (kind-of $m) list) {
            var @entries = (order &less-than={|a b|
              if (== $a[range][start][line] $b[range][start][line]) {
                put (< $a[range][start][character] $b[range][start][character])
              } else {
                put (< $a[range][start][line] $b[range][start][line])
              }
            } &reverse=$true $m)
            for entry $entries {
              apply $entry
            }
          } elif (not (is $m $nil)) {
            apply $m
          }
        }

        set content = (put [&jsonrpc=2.0 &id=$id &method=textDocument/formatting &params=[
          &textDocument=[
            &uri=file://$name
          ]
          &options=[
            &tabSize=(num 4)
            &insertSpaces=$false
          ]
        ]] | to-json)

        put "-------------> file tracking thread send: "$content
        printf "Content-Length: %d\r\n\r\n%s" (count $content) $content > $p
      }
    }
  }

  from-lines < $log | each {|l|
    try {
      handle (str:fields $l)
    } catch e {
      put $l
      put 'file tracking thread: error:'
      put $e
      put 'file tracking thread: exit'
      break
    }
  }
} {
  # Input reader thread (also the main thread)
  while $true {
    try {
      var l = (read-line)
      var @parts = (str:fields $l)
      var cmd = $parts[0]
      var file = $parts[1]

      put 'recv: '$l
      if (==s $cmd def) {
        if (< (count $parts) 4) {
          put "not enough parameters for definition, skip: "$l
          continue
        }
        var line = (num $parts[2])
        var char = (num $parts[3])

        set id = (+ $id 1)
        set content = (put [&jsonrpc=2.0 &id=$id &method=textDocument/definition &params=[
          &textDocument=[
            &uri=file://$file
          ]
          &position=[
            &line=$line
            &character=$char
          ]
        ]] | to-json)

        checkwin
        append (printf "\n%s:%d def: %s" $file (+ 1 $parts[2]) (read_line $file $parts[2]) | slurp)
      } elif (==s $cmd ref) {
        if (< (count $parts) 4) {
          put "not enough parameters for reference, skip: "$l
          continue
        }
        var line = (num $parts[2])
        var char = (num $parts[3])

        set id = (+ $id 1)
        set content = (put [&jsonrpc=2.0 &id=$id &method=textDocument/references &params=[
          &textDocument=[
            &uri=file://$file
          ]
          &position=[
            &line=$line
            &character=$char
          ]
          &context=[
            &includeDeclaration=$true
          ]
        ]] | to-json)

        checkwin
        append (printf "\n%s:%d refs: %s" $file (+ 1 $parts[2]) (read_line $file $parts[2]) | slurp)
      } elif (==s $cmd imp) {
        if (< (count $parts) 4) {
          put "not enough parameters for implementation, skip: "$l
          continue
        }
        var line = (num $parts[2])
        var char = (num $parts[3])

        set id = (+ $id 1)
        set content = (put [&jsonrpc=2.0 &id=$id &method=textDocument/implementation &params=[
          &textDocument=[
            &uri=file://$file
          ]
          &position=[
            &line=$line
            &character=$char
          ]
        ]] | to-json)

        checkwin
        append (printf "\n%s:%d impls: %s" $file (+ 1 $parts[2]) (read_line $file $parts[2]) | slurp)
      } elif (==s $cmd open) {
        if (has-key $opens $file) {
          continue
        }
        if (< (count $parts) 3) {
          put "not enough parameters for open, skip: "$l
          continue
        }
        var winid = $parts[2]

        set content = (put [&jsonrpc=2.0 &method=textDocument/didOpen &params=[
          &textDocument=[
            &uri=file://$file
            &languageId=(try { put (path:ext $file)[1..] } catch e { put unknown })
            &version=(num 0)
            &text=(9p read acme/$winid/body | slurp)
          ]
        ]] | to-json)

        set opens[$file] = $nil
        # close current window when tmux session exits.
        tmux set-hook -p 'alert-silence['$winid']' 'run "echo del | 9p write acme/'$winid'/ctl > /dev/null || true"'
      } else {
        put "skip unknown input: "$l
        continue
      }

      # register a display callback
      set cbs[$id] = {|m|
        var count = 0
        var addr
        var begin = (endoffset)
        var file
        if (==s (kind-of $m) list) {
          for entry $m {
            set file = $entry[uri][7..]
            set addr = (printf "%s:%d+#%d,%d+#%d" $file^
              $entry[range][start][line] $entry[range][start][character]^
              $entry[range][end][line] $entry[range][end][character]^
            )
            append (printf "%s %s\n" $addr (read_line $file $entry[range][start][line]))
            set count = (+ $count 1)
          }
        } else {
          set file = $m[uri][7..]
          set addr = (printf "%s:%d+#%d,%d+#%d" $file^
            $m[range][start][line] $m[range][start][character]^
            $m[range][end][line] $m[range][end][character]^
          )
          append (printf "%s %s\n" $addr (read_line $file $m[range][start][line]))
          set count = (+ $count 1)
        }

        # jump to it if there's only one result
        if (== $count 1) {
          9 plumb -s lsp -d edit -a 'envs=lsp_root:'$pwd $addr
        }

        # make sure the results are visible
        show $begin (endoffset)
      }

      put "-------------> input thread send: "$content
      printf "Content-Length: %d\r\n\r\n%s" (count $content) $content > $p

    } catch e {
      var reason = $e[reason]
      if (and (has-key $e[reason] type) (==s $reason[type] flow) (==s $reason[name] continue)) {
        continue
      } else {
        put 'input thread: error:'
        pprint $e
        break
      }
    }
  }

  put 'input thread: exit'
  file:close $p[w] # terminate server thread
  file:close $log # terminate file tracking thread
}