init.lua

--- mod-version:3.11
--
-- LSP client for Pragtical
-- @copyright Jefferson Gonzalez
-- @license MIT
--
-- Note: Annotations syntax documentation which is supported by
-- https://github.com/LuaLS/lua-language-server can be read here:
-- https://github.com/LuaLS/lua-language-server/wiki/Annotations

-- TODO Change the code to make it possible to use more than one LSP server
-- for a single file if possible and needed, for eg:
--   One lsp may not support goto definition but another one registered
--   for the current document filetype may do.

local core = require "core"
local common = require "core.common"
local config = require "core.config"
local command = require "core.command"
local style = require "core.style"
local keymap = require "core.keymap"
local translate = require "core.doc.translate"
local autocomplete = require "plugins.autocomplete"
local Doc = require "core.doc"
local DocView = require "core.docview"
local MarkdownView = require "core.markdownview"
local StatusView = require "core.statusview"
local RootView = require "core.rootview"
local contextmenu

local json = require "plugins.lsp.json"
local util = require "plugins.lsp.util"
local listbox = require "plugins.lsp.listbox"
local protocol = require "plugins.lsp.protocol"
local diagnostics = require "plugins.lsp.diagnostics"
local workspaceedit = require "plugins.lsp.workspaceedit"
local Server = require "plugins.lsp.server"
local Timer = require "plugins.lsp.timer"
local RenameSymbol = require "plugins.lsp.ui.renamesymbol"
local SymbolResults = require "plugins.lsp.ui.symbolresults"
local SymbolsTree = require "plugins.lsp.ui.symbolstree"
local MessageBox = require "widget.messagebox"
local snippets_found, snippets = pcall(require, "plugins.snippets")

---@alias lsp.plugin.location lsp.protocol.Location | lsp.protocol.LocationLink
---@alias lsp.plugin.locationlist lsp.plugin.location[]
---@alias lsp.plugin.symbollist lsp.protocol.DocumentSymbol[] | lsp.protocol.SymbolInformation[]
---@alias lsp.plugin.textedit lsp.protocol.TextEdit | lsp.protocol.InsertReplaceEdit
---@alias lsp.plugin.codeaction lsp.protocol.CodeAction | lsp.protocol.Command

---@class lsp.plugin.contentchange
---@field range lsp.protocol.Range
---@field text string

---@class lsp.plugin.positionparams : lsp.protocol.TextDocumentPositionParams
---@field context? lsp.protocol.CompletionContext | { includeDeclaration: boolean }
---@field newName? string

---@class lsp.plugin.workspaceconfigitem
---@field section? string
---@field scopeUri? lsp.protocol.DocumentUri

---@class lsp.plugin.workspaceconfigparams
---@field items lsp.plugin.workspaceconfigitem[]

---@class lsp.plugin.showdocumentparams
---@field external? boolean
---@field uri lsp.protocol.DocumentUri
---@field selection? lsp.protocol.Range
---@field takeFocus? boolean

---@class lsp.plugin.publishdiagnosticsparams
---@field uri lsp.protocol.DocumentUri
---@field diagnostics lsp.protocol.Diagnostic[]

---@class lsp.plugin.showmessageparams
---@field type lsp.protocol.MessageType
---@field message string

--
-- Main plugin functionality
--
local lsp = {}

--
-- Plugin settings
--

---Configuration options for the LSP plugin.
---@class config.plugins.lsp
---Set to a file path to log all json
---@field log_file string
---Setting to true prettyfies json for more readability on the log
---but this setting will impact performance so only enable it when
---in need of easy to read json output when developing the plugin.
---@field prettify_json boolean
---Show a symbol hover information when mouse cursor is on top.
---@field mouse_hover boolean
---The amount of time in milliseconds before showing the tooltip.
---@field mouse_hover_delay integer
---Show diagnostic messages
---@field show_diagnostics boolean
---Amount of milliseconds to delay updating the inline diagnostics.
---@field diagnostics_delay number
---Wether to enable snippets processing.
---@field snippets boolean
---Allow the application of additional text edits on completion, eg: #includes, imports, etc...
---@field apply_additional_edits boolean
---Stop servers that aren't needed by any of the open files
---@field stop_unneeded_servers boolean
---The amount of seconds to keep the server active before stopping it
---@field server_quit_timeout number
---Send a server stderr output to pragtical log
---@field log_server_stderr boolean
---Force verbosity off even if a server is configured with verbosity on
---@field force_verbosity_off boolean
---Yield when reading from LSP which may give you better UI responsiveness
---when receiving large responses, but will affect LSP performance.
---@field more_yielding boolean
---The amount of times per second to check for new server data.
---@field checks_per_second number
---Determines the default visibility of the symbols tree.
---@field symbolstree_visibility "show" | "hide" | "auto"
---Request a document format after a save.
---@field request_format_on_save bool
config.plugins.lsp = common.merge({
  mouse_hover = true,
  mouse_hover_delay = 300,
  show_diagnostics = true,
  diagnostics_delay = 500,
  snippets = true,
  apply_additional_edits = true,
  stop_unneeded_servers = true,
  server_quit_timeout = 60,
  log_file = "",
  prettify_json = false,
  log_server_stderr = false,
  force_verbosity_off = false,
  more_yielding = false,
  checks_per_second = 25,
  autostart_server = true,
  symbolstree_visibility = "auto",
  symbolstree_width = 300 * SCALE,
  request_format_on_save = false,
  -- The config specification used by the settings gui
  config_spec = {
    name = "Language Server Protocol",
    {
      label = "Mouse Hover",
      description = "Show a symbol hover information when mouse cursor is on top.",
      path = "mouse_hover",
      type = "TOGGLE",
      default = true
    },
    {
      label = "Mouse Hover Delay",
      description = "The amount of time in milliseconds before showing the tooltip.",
      path = "mouse_hover_delay",
      type = "NUMBER",
      default = 300,
      min = 50,
      max = 2000
    },
    {
      label = "Diagnostics",
      description = "Show inline diagnostic messages with lint+.",
      path = "show_diagnostics",
      type = "TOGGLE",
      default = false
    },
    {
      label = "Diagnostics Delay",
      description = "Amount of milliseconds to delay the update of inline diagnostics.",
      path = "diagnostics_delay",
      type = "NUMBER",
      default = 500,
      min = 100,
      max = 10000
    },
    {
      label = "Snippets",
      description = "Snippets processing using lsp_snippets, may need a restart.",
      path = "snippets",
      type = "TOGGLE",
      default = true
    },
    {
      label = "Apply Additional Completion Edits",
      description = "Allow the application of additional text edits on completion, eg: #includes, imports, etc...",
      path = "apply_additional_edits",
      type = "TOGGLE",
      default = true
    },
    {
      label = "Autostart Server",
      description = "Automatically start server when opening a file",
      path = "autostart_server",
      type = "TOGGLE",
      default = true
    },
    {
      label = "Stop Servers",
      description = "Stop servers that aren't needed by any of the open files.",
      path = "stop_unneeded_servers",
      type = "TOGGLE",
      default = true
    },
    {
      label = "Stop Servers Timeout",
      description = "Amount of seconds to keep a server active before stopping it.",
      path = "server_quit_timeout",
      type = "NUMBER",
      default = 60,
      min = 0,
      max = 300
    },
    {
      label = "Log File",
      description = "Absolute path to a '.log' file for logging all json.",
      path = "log_file",
      type = "FILE",
      filters = {"%.log$"}
    },
    {
      label = "Prettify JSON",
      description = "Prettify json for more readability but impacts performance.",
      path = "prettify_json",
      type = "TOGGLE",
      default = false
    },
    {
      label = "Log Standard Error",
      description = "Send a server stderr output to pragtical log.",
      path = "log_server_stderr",
      type = "TOGGLE",
      default = false
    },
    {
      label = "Force Verbosity Off",
      description = "Turn verbosity off even if a server is configured with verbosity on.",
      path = "force_verbosity_off",
      type = "TOGGLE",
      default = false
    },
    {
      label = "More Yielding",
      description = "Yield when reading from LSP which may give you better UI responsiveness.",
      path = "more_yielding",
      type = "TOGGLE",
      default = false
    },
    {
      label = "Checks Per Second",
      description = "The amount of times per second to check for new server data. Higher is faster but consumes more CPU.",
      path = "checks_per_second",
      type = "NUMBER",
      default = 25,
      min = 10,
      max = 100,
      step = 1
    },
    {
      label = "Symbols Tree Visibility",
      description = "Default visibility mode of the document symbols tree.",
      path = "symbolstree_visibility",
      type = "selection",
      default = "auto",
      values = {
        { "Auto", "auto" },
        { "Show", "show" },
        { "Hide", "hide" },
      },
      on_apply = function(value)
        if value == "auto" then
          lsp.symbols_tree:set_auto_hide(true)
        else
          lsp.symbols_tree:set_auto_hide(false)
          if value == "show" then
            lsp.symbols_tree:show()
          else
            lsp.symbols_tree:hide()
          end
        end
      end
    },
    {
      label = "Symbols Tree Width",
      description = "Default width for the symbols tree pane.",
      path = "symbolstree_width",
      type = "number",
      default = 300 * SCALE,
      get_value = function(value)
        return value / SCALE
      end,
      set_value = function(value)
        return value * SCALE
      end,
      on_apply = function(value)
        lsp.symbols_tree:set_size(value)
      end
    },
    {
      label = "Request Document Format on Save",
      description = "Request a document format after save. Due to the nature of LSP this will produce a second document save after receiving the formatted code.",
      path = "request_format_on_save",
      type = "TOGGLE",
      default = false
    },
  }
}, config.plugins.lsp)

---List of registered servers
---@type table<string, lsp.server.options>
lsp.servers = {}

---List of running servers
---@type table<string, lsp.server>
lsp.servers_running = {}

---Flag that indicates if last autocomplete request was a trigger
---to prevent requesting another autocompletion request until the
---autocomplete box is hidden since some lsp servers loose context
---and return wrong results (eg: lua-language-server)
---@type boolean
lsp.in_trigger = false

---Flag that indicates if the user typed something on the editor to try and
---call autocomplete only when neccesary.
---@type boolean
lsp.user_typed = false

---Used on the hover timer to display hover info
---@class lsp.hover_position
---@field doc core.doc | nil
---@field line integer
---@field col integer
---@field triggered boolean
lsp.hover_position = {doc = nil, line = 0, col = 0, triggered = false}

---@type lsp.timer
lsp.hover_timer = Timer(300, true)

lsp.hover_timer.on_timer = function()
  lsp.request_hover(
    lsp.hover_position.doc,
    lsp.hover_position.line,
    lsp.hover_position.col
  )
end

--
-- Private functions
--

---Generate an lsp location object
---@param doc core.doc
---@param line integer
---@param col integer
---@return lsp.plugin.positionparams
local function get_buffer_position_params(doc, line, col)
  return {
    textDocument = {
      uri = util.touri(core.project_absolute_path(doc.filename)),
    },
    position = {
      line = line - 1,
      character = util.doc_utf8_to_utf16(doc, line, col) - 1
    }
  }
end

---Generate an lsp text document range object.
---@param doc core.doc
---@param line1 integer
---@param col1 integer
---@param line2 integer
---@param col2 integer
---@return lsp.protocol.CodeActionParams
local function get_buffer_range_params(doc, line1, col1, line2, col2)
  if line2 < line1 or (line2 == line1 and col2 < col1) then
    line1, col1, line2, col2 = line2, col2, line1, col1
  end

  return {
    textDocument = {
      uri = util.touri(core.project_absolute_path(doc.filename)),
    },
    range = {
      start = {
        line = line1 - 1,
        character = util.doc_utf8_to_utf16(doc, line1, col1) - 1
      },
      ["end"] = {
        line = line2 - 1,
        character = util.doc_utf8_to_utf16(doc, line2, col2) - 1
      }
    },
    context = {
      diagnostics = {}
    }
  }
end

---@param a lsp.protocol.Position
---@param b lsp.protocol.Position
local function position_le(a, b)
  return a.line < b.line or (a.line == b.line and a.character <= b.character)
end

---@param range lsp.protocol.Range
---@param diagnostic lsp.protocol.Diagnostic
local function range_intersects_diagnostic(range, diagnostic)
  local d_range = diagnostic.range
  return position_le(range.start, d_range["end"])
    and position_le(d_range.start, range["end"])
end

---Collect document diagnostics that overlap a range.
---@param doc core.doc
---@param range lsp.protocol.Range
---@return lsp.protocol.Diagnostic[]
local function get_code_action_diagnostics(doc, range)
  local diagnostic_messages = diagnostics.get(doc.filename)
    or diagnostics.get(core.project_absolute_path(doc.filename))
    or diagnostics.get(core.normalize_to_project_dir(doc.abs_filename or doc.filename))
  local result = {}

  for _, diagnostic in ipairs(diagnostic_messages or {}) do
    if range_intersects_diagnostic(range, diagnostic) then
      table.insert(result, diagnostic)
    end
  end

  return result
end

---Check if the current document range has diagnostics that can drive actions.
---@param doc core.doc
---@param line1 integer
---@param col1 integer
---@param line2 integer
---@param col2 integer
---@return boolean
local function has_code_action_diagnostics(doc, line1, col1, line2, col2)
  local request_params = get_buffer_range_params(doc, line1, col1, line2, col2)
  return #get_code_action_diagnostics(doc, request_params.range) > 0
end

---Recursive function to generate a list of symbols ready
---to use for the lsp.request_document_symbols() action.
---@param list lsp.plugin.symbollist
---@param parent? string
local function get_symbol_lists(list, parent)
  local symbols = {}
  local symbol_names = {}
  parent = parent or ""
  parent = #parent > 0 and (parent .. "/") or parent

  for _, symbol in pairs(list) do
    -- Include symbol kind to be able to filter by it
    local symbol_name = parent
      .. symbol.name
      .. "||" .. Server.get_symbol_kind(symbol.kind)

    table.insert(symbol_names, symbol_name)

    symbols[symbol_name] = { kind = symbol.kind }

    if symbol.location then
      symbols[symbol_name].location = symbol.location
    else
      if symbol.range then
        symbols[symbol_name].range = symbol.range
      end
      if symbol.uri then
        symbols[symbol_name].uri = symbol.uri
      end
    end

    if symbol.children and #symbol.children > 0 then
      local child_symbols, child_names = get_symbol_lists(
        symbol.children, parent .. symbol.name
      )

      for _, name in pairs(child_names) do
        table.insert(symbol_names, name)
        symbols[name] = child_symbols[name]
      end
    end
  end

  return symbols, symbol_names
end

local function log(server, message, ...)
  if server.verbose then
    core.log("["..server.name.."] " .. message, ...)
  else
    core.log_quiet("["..server.name.."] " .. message, ...)
  end
end

---Check if active view is a DocView and return it
---@return core.docview|nil
local function get_active_docview()
  local av = core.active_view
  if getmetatable(av) == DocView and av.doc and av.doc.filename then
    return av
  end
  return nil
end

---Generates a code preview of a location
---@param location lsp.plugin.location
local function get_location_preview(location)
  local line1, col1 = util.toselection(
    location.range or location.targetRange
  )
  local filename = core.normalize_to_project_dir(
    util.tofilename(location.uri or location.targetUri)
  )
  local abs_filename = core.project_absolute_path(filename)

  local file = io.open(abs_filename)

  if not file then
    return "", filename .. ":" .. tostring(line1) .. ":" .. tostring(col1)
  end

  local preview = ""

  -- sometimes the lsp can send the location of a definition where the
  -- doc comments should be written but if no docs are written the line
  -- is empty and subsequent line is the one we are interested in.
  local line_count = 1
  for line in file:lines() do
    if line_count >= line1 then
      preview = line:gsub("^%s+", "")
        :gsub("%s+$", "")

      if preview ~= "" then
        break
      else
        -- change also the location table
        if location.range then
          location.range.start.line = location.range.start.line + 1
          location.range['end'].line = location.range['end'].line + 1
        elseif location.targetRange then
          location.targetRange.start.line = location.targetRange.start.line + 1
          location.targetRange['end'].line = location.targetRange['end'].line + 1
        end
      end
    end
    line_count = line_count + 1
  end
  file:close()

  local position = filename .. ":" .. tostring(line1) .. ":" .. tostring(col1)

  return preview, position
end

---Generate a list ready to use for the lsp.request_references() action.
---@param locations lsp.plugin.locationlist
local function get_references_lists(locations)
  local references, reference_names = {}, {}

  for _, location in pairs(locations) do
    local preview, position = get_location_preview(location)
    local name = preview .. "||" .. position
    table.insert(reference_names, name)
    references[name] = location
  end

  return references, reference_names
end

---Apply a completion text edit to a document if possible.
---@param server lsp.server
---@param doc core.doc
---@param text_edit lsp.plugin.textedit
---@param is_snippet boolean
---@param update_cursor_position boolean
---@return boolean True on success
local function apply_completion_edit(
  server, doc, text_edit, is_snippet, update_cursor_position
)
  local range = nil

  if text_edit.range then
    range = text_edit.range
  elseif text_edit.insert then
    range = text_edit.insert
  elseif text_edit.replace then
    range = text_edit.replace
  end

  if not range then return false end

  local text = text_edit.newText
  local line1, col1, line2, col2
  local current_text = ""

  if
    not server.capabilities.positionEncoding
    or
    server.capabilities.positionEncoding == protocol.PositionEncodingKind.UTF16
  then
    line1, col1, line2, col2 = util.toselection(range, doc)
  else
    core.error(
      "[LSP] Unsupported position encoding: ",
      server.capabilities.positionEncoding
    )
    return false
  end

  if lsp.in_trigger then
    local cline2, ccol2 = doc:get_selection()
    local cline1, ccol1 = doc:position_offset(line2, col2, translate.start_of_word)
    current_text = doc:get_text(cline1, ccol1, cline2, ccol2)
  end

  if is_snippet and snippets_found and config.plugins.lsp.snippets then
    doc:remove(line1, col1, line2, col2 + #current_text)
    doc:set_selection(line1, col1, line1, col1)
    snippets.execute {format = 'lsp', template = text}
    return true
  end

  if not workspaceedit.apply_text_edit(server, doc, text_edit, #current_text) then
    return false
  end

  if update_cursor_position then
    doc:move_to_cursor(nil, #text)
  end

  return true
end

---Callback given to autocomplete plugin which is executed once for each
---element of the autocomplete box which is hovered with the idea of providing
---better description of the selected element by requesting the LSP server for
---detailed information/documentation.
---@param index integer
---@param item autocomplete.item
local function autocomplete_onhover(index, item)
  local completion_item = item.data.completion_item

  if item.data.server.verbose then
    item.data.server:log(
      "Resolve item: %s", util.jsonprettify(json.encode(completion_item))
    )
  end

  -- Only send resolve request if data field (which should contain
  -- the item id) is available.
  if completion_item.data then
    item.data.server:push_request('completionItem/resolve', {
      params = completion_item,
      callback = function(server, response)
        if response.result then
          local symbol = response.result
          if symbol.detail and #item.desc <= 0 then
            item.desc = symbol.detail
          end
          if symbol.documentation then
            if #item.desc > 0 then
              item.desc = item.desc .. "\n\n"
            end
            if
              type(symbol.documentation) == "table"
              and
              symbol.documentation.value
            then
              item.desc = item.desc .. symbol.documentation.value
            else
              item.desc = item.desc .. symbol.documentation
            end
          end
          item.desc = item.desc:gsub("[%s\n]+$", "")
            :gsub("^[%s\n]+", "")
            :gsub("\n\n\n+", "\n\n")

          if server.verbose then
            server:log(
              "Resolve response: %s", util.jsonprettify(json.encode(symbol))
            )
          end
        elseif server.verbose then
          server:log("Resolve returned empty response")
        end
        item.data.resolved = true
      end
    })
  end
end

---Callback that handles insertion of an autocompletion item that has
---the information of insertion
---@param index integer
---@param item autocomplete.item
local function autocomplete_onselect(index, item)
  local completion = item.data.completion_item
  local dv = get_active_docview()
  local edit_applied = false
  if completion.textEdit then
    if dv then
      -- Restore previous partial since the complete request is async and
      -- new text could have been written while retrieving autocomplete items
      -- which results in invalid insert positions if we don't revert partial
      local current_partial = {autocomplete.get_partial_symbol()}
      if current_partial[1] ~= item.data.partial[1] then
        local partial, pl1, pc1, pl2, pc2 = table.unpack(current_partial)
        dv.doc:remove(pl1, pc1, pl2, pc2)
        partial, pl1, pc1 = table.unpack(item.data.partial)
        dv.doc:insert(pl1, pc1, partial)
      end
      local is_snippet = completion.insertTextFormat
        and completion.insertTextFormat == protocol.InsertTextFormat.Snippet
      edit_applied = apply_completion_edit(
        item.data.server, dv.doc, completion.textEdit, is_snippet, true
      )
      if edit_applied then
        -- Retrigger code completion if last char is a trigger
        -- this is useful for example with clangd when autocompleting
        -- a #include, if user types < a list of paths will appear
        -- when selecting a path that ends with / as <AL/ the
        -- autocompletion will be retriggered to show a list of
        -- header files that belong to that directory.
        lsp.in_trigger = false
        local line, col = dv.doc:get_selection()
        local char = dv.doc:get_char(line, col-1)
        local char_prev = dv.doc:get_char(line, col-2)
        if char:match("%p") or (char == " " and char_prev:match("%p")) then
          if not util.table_empty(dv.doc.lsp_changes) then
            lsp.update_document(dv.doc, true)
          else
            lsp.request_completion(dv.doc, line, col, true)
          end
        end
      end
    end
  elseif
    dv and snippets_found and config.plugins.lsp.snippets
    and
    completion.insertText and completion.insertTextFormat
    and
    completion.insertTextFormat == protocol.InsertTextFormat.Snippet
  then
    ---@type core.doc
    local doc = dv.doc
    if dv then
      local _, line1, col1, line2, col2 = autocomplete.get_partial_symbol()
      doc:set_selection(line1, col1, line2, col2)
      snippets.execute {format = 'lsp', template = completion.insertText}
      edit_applied = true
    end
  end
  if
    dv and edit_applied and completion.additionalTextEdits
    and
    config.plugins.lsp.apply_additional_edits
  then
    -- TODO: Breaks snippets execution, in future we should apply additional
    -- edits first and update completion item range before insert
    core.add_thread(function()
      while not item.data.resolved do coroutine.yield() end
      workspaceedit.apply_text_edits(
        item.data.server, dv.doc, completion.additionalTextEdits
      )
    end)
  end
  return edit_applied
end

--
-- Public functions
--

---Open a document location returned by LSP
---@param location lsp.plugin.location
function lsp.goto_location(location)
  local doc_view = core.root_view:open_doc(
    core.open_doc(
      common.home_expand(
        util.tofilename(location.uri or location.targetUri)
      )
    )
  )
  local line1, col1 = util.toselection(
    location.range or location.targetRange, doc_view.doc
  )
  doc_view.doc:set_selection(line1, col1, line1, col1)
end

lsp.get_location_preview = get_location_preview

---Register an LSP server to be launched on demand
---@param options lsp.server.options
function lsp.add_server(options)
  local required_fields = {
    "name", "language", "file_patterns"
  }

  for _, field in pairs(required_fields) do
    if not options[field] then
      core.error(
        "[LSP] You need to provide a '%s' field for the server.",
        field
      )
      return false
    end
  end

  if snippets_found and config.plugins.lsp.snippets then
    options.snippets = true
  end

  options.transport = options.transport or "stdio"

  if options.transport == "tcp" then
    if not options.host or options.host == "" then
      core.error("[LSP] Provide a host for tcp lsp servers.")
      return false
    end
    if not options.port then
      core.error("[LSP] Provide a port for tcp lsp servers.")
      return false
    end
  end

  if options.transport == "stdio" and (not options.command or #options.command <= 0) then
    core.error("[LSP] Provide a command table list with the lsp command.")
    return false
  end

  if not options.quit_timeout then
    options.quit_timeout = config.plugins.lsp.server_quit_timeout or 60
  end

  -- some lsp servers may be installed with different binary names
  -- so if command name is a list, search for one that exists
  if options.command and type(options.command[1]) == "table" then
    options.command[1] = util.get_best_executable(options.command[1])
  end

  -- On Windows use cmd.exe only for commands that need shell resolution or
  -- script interpretation. Native .exe/.com programs are launched directly so
  -- process termination targets the actual server.
  if
    PLATFORM == "Windows"
    and options.command
    and not options.windows_skip_cmd
    and not util.win_command_is_executable(options.command[1])
  then
    table.insert(options.command, 1, "/C")
    table.insert(options.command, 1, "cmd.exe")
  end

  if config.plugins.lsp.force_verbosity_off then
    options.verbose = false
  end

  lsp.servers[options.name] = options

  return true
end

---Get valid running lsp servers for a given filename
---@param filename string
---@param initialized boolean
---@return table active_servers
function lsp.get_active_servers(filename, initialized)
  local servers = {}
  for name, server in pairs(lsp.servers) do
    if common.match_pattern(filename, server.file_patterns) then
      if lsp.servers_running[name] then
        local add_server = true
        if
          initialized
          and
          (
            not lsp.servers_running[name].initialized
            or
            not lsp.servers_running[name].capabilities
          )
        then
          add_server = false
        end
        if add_server then
          table.insert(servers, name)
        end
      end
    end
  end
  return servers
end

-- Used on lsp.get_workspace_settings()
local cached_workspace_settings = {}
local cached_workspace_settings_timestamp = 0

---Get table of configuration settings in the following way:
---1. Scan the USERDIR for .pragtical_lsp.lua or .pragtical_lsp.json (in that order)
---2. Merge server.settings
---4. Scan workspace if set also for .pragtical_lsp.lua/json and merge them or
---3. Scan server.path also for .pragtical_lsp.lua/json and merge them
---Note: settings are cached for 5 seconds for faster retrieval
---      on repetitive calls to this function.
---@param server lsp.server
---@param workspace? string
---@return lsp.protocol.LSPObject
function lsp.get_workspace_settings(server, workspace)
  -- Search settings on the following directories, subsequent settings
  -- overwrite the previous ones
  local paths = { USERDIR }
  local cached_index = USERDIR
  local settings = {}

  if not workspace and server.path then
    table.insert(paths, server.path)
    cached_index = cached_index .. tostring(server.path)
  elseif workspace then
    table.insert(paths, workspace)
    cached_index = cached_index .. tostring(workspace)
  end

  if
    cached_workspace_settings_timestamp > os.time()
    and
    cached_workspace_settings[cached_index]
  then
    return cached_workspace_settings[cached_index]
  else
    local position = 1
    for _, path in pairs(paths) do
      if path then
        local settings_new = nil
        path = path:gsub("\\+$", ""):gsub("/+$", "")
        if util.file_exists(path .. "/.pragtical_lsp.lua") then
          local settings_lua = dofile(path .. "/.pragtical_lsp.lua")
          if type(settings_lua) == "table" then
            settings_new = settings_lua
          end
        elseif util.file_exists(path .. "/.pragtical_lsp.json") then
          local file = io.open(path .. "/.pragtical_lsp.json", "r")
          if file then
            local settings_json = file:read("*a")
            settings_new = json.decode(settings_json)
            file:close()
          end
        end

        -- overwrite global settings by those specified in the server if any
        if position == 1 and server.settings then
          if settings_new then
            settings_new = util.deep_merge(settings_new, server.settings)
          else
            settings_new = server.settings
          end
        end

        -- overwrite previous settings with new ones
        if settings_new then
          settings = util.deep_merge(settings, settings_new)
        end
      end

      position = position + 1
    end

    -- store settings on cache for 5 seconds for fast repeated calls
    cached_workspace_settings[cached_index] = settings
    cached_workspace_settings_timestamp = os.time() + 5
  end

  return settings
end

-- TODO Update workspace folders of already running lsp servers if required
--- Start all applicable lsp servers for a given file.
--- @param filename string
--- @param project_directory string
function lsp.start_server(filename, project_directory)
  local server_started = false
  local server_registered = false
  local servers_not_found = {}
  for name, server in pairs(lsp.servers) do
    if common.match_pattern(filename, server.file_patterns) then
      server_registered = true
      if lsp.servers_running[name] then
        server_started = true
      end

      local command_exists = false
      if server.command and server.command[1] then
        if util.command_exists(server.command[1]) then
          command_exists = true
        else
          table.insert(servers_not_found, name)
        end
      elseif server.transport == "tcp" then
        command_exists = true
      end

      if not lsp.servers_running[name] and command_exists then
        core.log("[LSP] starting " .. name)
        ---@type lsp.server
        local client = Server(server)
        if client.shutdown_reason then
          core.error("[LSP] %s failed to start: %s", name, client.shutdown_reason)
        else
          client.yield_on_reads = config.plugins.lsp.more_yielding

          lsp.servers_running[name] = client

          -- We overwrite the default log function to log messages on pragtical
          function client:log(message, ...)
            core.log_quiet(
              "[LSP/%s]: " .. message .. "\n",
              self.name,
              ...
            )
          end

          function client:on_shutdown()
            local sname = self.name
            local restarts_count = self.restarts_count or 0
            local max_restarts = self.max_restarts or -1
            if self.shutdown_reason then
              core.log("[LSP]: %s was shutdown: %s", sname, self.shutdown_reason)
            else
              core.log(
                "[LSP]: %s was shutdown, revise your configuration",
                sname
              )
            end
            local last_shutdown = lsp.servers_running[sname] and lsp.servers_running[sname].last_shutdown or 0
            lsp.servers_running = util.table_remove_key(
              lsp.servers_running,
              sname
            )
            if max_restarts > -1 and restarts_count >= max_restarts then
              core.log(
                "[LSP]: %s reached the maximum amount of automatic restarts",
                sname
              )
              return
            end
            if system.get_time() - last_shutdown >= 5 then
              lsp.start_servers()
              if lsp.servers_running[sname] then
                lsp.servers_running[sname].last_shutdown = system.get_time()
                lsp.servers_running[sname].restarts_count = restarts_count + 1
                lsp.servers_running[sname].max_restarts = max_restarts
                core.log(
                  "[LSP]: %s automatically restarted",
                  sname
                )
              end
            end
          end

          -- Respond to workspace/configuration request
          client:add_request_listener(
          "workspace/configuration",
          function(server, request)
            ---@type lsp.plugin.workspaceconfigparams
            local params = request.params
            local settings_default = lsp.get_workspace_settings(server)

            local settings_list = {}
            for _, item in pairs(params.items) do
              local value = nil
              if item.section then
                -- No workspace was specified so we return from default settings
                if not item.scopeUri then
                  value = util.table_get_field(settings_default, item.section)
                -- A workspace was specified so we return from that workspace
                else
                  local settings_workspace = lsp.get_workspace_settings(
                    server, util.tofilename(item.scopeUri)
                  )
                  value = util.table_get_field(settings_workspace, item.section)
                end

                if not value then
                  server:log("Asking for '%s' config but not set", item.section)
                else
                  server:log("Asking for '%s' config", item.section)
                end
              end

              table.insert(settings_list, value or json.null)
            end
            server:push_response(request.method, request.id, settings_list)
          end
        )

        -- Respond to window/showDocument request
        client:add_request_listener(
          "window/showDocument",
          function(server, request)
            ---@type lsp.plugin.showdocumentparams
            local params = request.params
            if params.external then
              MessageBox.info(
                server.name .. " LSP Server",
                "Wants to externally open:\n'" .. params.uri .. "'",
                function(_, button_id)
                  if button_id == 1 then
                    common.open_in_system(params.uri)
                  end
                end,
                MessageBox.BUTTONS_YES_NO
              )
            else
              local document = util.tofilename(params.uri)
              ---@type core.docview
              local doc_view = core.root_view:open_doc(
                core.open_doc(common.home_expand(document))
              )
              if params.selection then
                local line1, col1, line2, col2 = util.toselection(
                  params.selection, doc_view.doc
                )
                doc_view.doc:set_selection(line1, col1, line2, col2)
              end
              if params.takeFocus then
                system.raise_window(core.window)
              end
            end

            server:push_response(request.method, request.id, {success=true})
          end
        )

        client:add_request_listener(
          "workspace/applyEdit",
          function(server, request)
            ---@type lsp.protocol.ApplyWorkspaceEditParams
            local params = request.params
            local applied = lsp.apply_workspace_edit(server, params.edit)
            ---@type lsp.protocol.ApplyWorkspaceEditResult
            local result = { applied = applied }
            if not applied then
              result.failureReason = "Could not apply workspace edit"
            end
            server:push_response(request.method, request.id, result)
          end
        )

        -- Display server messages on pragtical UI
        client:add_message_listener(
          "window/logMessage",
          function(server, params)
            ---@cast params lsp.plugin.showmessageparams
            if core.log then
              log(server, "%s", params.message)
            end
          end
        )

        -- Register/unregister diagnostic messages
        client:add_message_listener(
          "textDocument/publishDiagnostics",
          function(server, params)
            ---@cast params lsp.plugin.publishdiagnosticsparams
            local abs_filename = util.tofilename(params.uri)
            local filename = core.normalize_to_project_dir(abs_filename)

            if server.verbose then
              core.log_quiet(
                "["..server.name.."] %s diagnostics for:  %s",
                filename,
                params.diagnostics and #params.diagnostics or 0
              )
            end

            if params.diagnostics and #params.diagnostics > 0 then
              local added = diagnostics.add(filename, params.diagnostics)

              if
                added and diagnostics.lintplus_found
                and
                config.plugins.lsp.show_diagnostics
                and
                util.doc_is_open(abs_filename)
              then
                -- we delay rendering of diagnostics for 2 seconds to prevent
                -- the constant reporting of errors while typing.
                diagnostics.lintplus_populate_delayed(filename)
              end
            else
              diagnostics.clear(filename)
              diagnostics.lintplus_clear_messages(filename)
            end
          end
        )

        -- Register/unregister diagnostic messages
        client:add_message_listener(
          "window/showMessage",
          function(server, params)
            ---@cast params lsp.plugin.showmessageparams
            local log_func = "log_quiet"
            if params.type == protocol.MessageType.Error then
              log_func = "error"
            elseif params.type == protocol.MessageType.Warning then
              log_func = "warn"
            elseif params.type == protocol.MessageType.Info then
              log_func = "log"
            elseif params.type == protocol.MessageType.Debug then
              log_func = "log_quiet"
            end
            core[log_func]("["..server.name.."] message: %s", params.message)
          end
        )

        -- Send settings table after initialization if available.
        client:add_event_listener("initialized", function(server)
          server.restarts_count = 0
          server.max_restarts = -1
          if config.plugins.lsp.force_verbosity_off then
            core.log_quiet("["..server.name.."] " .. "Initialized")
          else
            log(server, "Initialized")
          end
          local settings = lsp.get_workspace_settings(server)
          if not util.table_empty(settings) then
            server:push_notification("workspace/didChangeConfiguration", {
              params = {settings = settings}
            })
          end

          -- Send open document request if needed
          for _, docu in ipairs(core.docs) do
            if docu.filename then
              if common.match_pattern(docu.filename, server.file_patterns) then
                lsp.open_document(docu)
              end
            end
          end
        end)

          -- Start the server initialization process
          client:initialize(project_directory, "Pragtical", VERSION)
        end
      end
    end
  end

  if server_registered and not server_started then
    for _,_ in pairs(servers_not_found) do
      core.error(
        "[LSP] servers registered but not installed: %s",
        table.concat(servers_not_found, ", ")
      )
      break
    end
  end
end

---Stops all running servers.
function lsp.stop_servers()
  for name, _ in pairs(lsp.servers) do
    if lsp.servers_running[name] then
       lsp.servers_running[name]:exit()
       core.log("[LSP] stopped %s", name)
       lsp.servers_running = util.table_remove_key(lsp.servers_running, name)
    end
  end
end

---Start only the needed servers by current opened documents.
function lsp.start_servers()
  for _, doc in ipairs(core.docs) do
    if doc.filename then
      lsp.start_server(doc.filename, core.root_project().path)
    end
  end
end

---Returns the hovered doc and the hovered position.
---Returns nil if no doc with an LSP activated is under the provided coordinates.
---@param x number
---@param y number
---@return core.doc|nil doc
---@return integer|nil line
---@return integer|nil col
function lsp.get_hovered_location(x, y)
  local n = core.root_view.root_node:get_child_overlapping_point(x, y)
  if not n then return end
  local av = n.active_view
  if not av:extends(DocView) then return end
  if av and av.doc.lsp_open then
    ---@type core.doc
    local doc = av.doc
    local line, col = av:resolve_screen_position(x, y)
    local last_x = av:get_col_x_offset(line, #av.doc.lines[line])
    local lx, ly = av:get_line_screen_position(line, col)
    if x > last_x + lx or y > ly + av:get_line_height() then return end
    return doc, line, col
  end
end

---Send notification to applicable LSP servers that a document was opened
---@param doc core.doc
function lsp.open_document(doc)
  -- in some rare ocassions this may be set to nil when the
  -- user closed pragtical with files opened, removed the files from system
  -- and opens pragtical again which loads the non existent files.
  local doc_path = doc.abs_filename
  local file_info = doc_path and system.get_file_info(doc_path) or false
  if not file_info then
    core.error("[LSP] could not open: %s", tostring(doc.filename))
    return
  end

  local active_servers = lsp.get_active_servers(doc.filename, true)

  if #active_servers > 0 then
    for _, name in pairs(active_servers) do
      local server = lsp.servers_running[name]
      if server.capabilities.textDocumentSync.openClose then
        if server.exit_timer then
          server.exit_timer:stop()
          server.exit_timer = nil
        end
        if file_info.size / 1024 <= 50 then
          -- file size is in range so push the notification as usual.
          server:push_notification('textDocument/didOpen', {
            params = {
              textDocument = {
                uri = util.touri(doc_path),
                languageId = server:get_language_id(doc),
                version = doc.clean_change_id,
                text = table.concat(doc.lines)
              }
            },
            callback = function() doc.lsp_open = true end
          })
        else
          -- big files too slow for json encoder, also sending a huge file
          -- without yielding would stall the ui, and some lsp servers have
          -- issues with receiving big files in a single chunk.
          local text = table.concat(doc.lines)
            :gsub('\\', '\\\\'):gsub("\n", "\\n"):gsub("\r", "\\r")
            :gsub("\t", "\\t"):gsub('"', '\\"'):gsub('\b', '\\b')
            :gsub('\f', '\\f')

          server:push_raw("textDocument/didOpen", {
            raw_data = '{\n'
            .. '"jsonrpc": "2.0",\n'
            .. '"method": "textDocument/didOpen",\n'
            .. '"params": {\n'
            .. '"textDocument": {\n'
            .. '"uri": "'..util.touri(doc_path)..'",\n'
            .. '"languageId": "'..server:get_language_id(doc)..'",\n'
            .. '"version": '..doc.clean_change_id..',\n'
            .. '"text": "'..text..'"\n'
            .. '}\n'
            .. '}\n'
            .. '}\n',
            callback = function(server)
              doc.lsp_open = true
              log(server, "Big file '%s' ready for completion!", doc.filename)
            end
          })

          log(server, "Processing big file '%s'...", doc.filename)
        end
      else
        doc.lsp_open = true
      end
    end
  end
end

--- Send notification to applicable LSP servers that a document was saved
---@param doc core.doc
function lsp.save_document(doc)
  if not doc.lsp_open then return end

  local active_servers = lsp.get_active_servers(doc.filename, true)
  if #active_servers > 0 then
    for _, name in pairs(active_servers) do
      local server = lsp.servers_running[name]
      local save = server.capabilities.textDocumentSync.save
      if save then
        -- Send document content only if required by lsp server
        if save.includeText then
          -- If save should include file content then raw is faster for
          -- huge files that would take too much to encode.
          local text = table.concat(doc.lines)
            :gsub('\\', '\\\\'):gsub("\n", "\\n"):gsub("\r", "\\r")
            :gsub("\t", "\\t"):gsub('"', '\\"'):gsub('\b', '\\b')
            :gsub('\f', '\\f')

          server:push_raw("textDocument/didSave", {
            raw_data = '{\n'
            .. '"jsonrpc": "2.0",\n'
            .. '"method": "textDocument/didSave",\n'
            .. '"params": {\n'
            .. '"textDocument": {\n'
            .. '"uri": "'..util.touri(core.project_absolute_path(doc.filename))..'"\n'
            .. '},\n'
            .. '"text": "'..text..'"\n'
            .. '}\n'
            .. '}\n'
          })
        else
          server:push_notification('textDocument/didSave', {
            params = {
              textDocument = {
                uri = util.touri(core.project_absolute_path(doc.filename))
              }
            }
          })
        end

        ::continue::
      end
    end
  end
end

--- Send notification to applicable LSP servers that a document was closed
---@param doc core.doc
function lsp.close_document(doc)
  if not doc.lsp_open then return end

  local active_servers = lsp.get_active_servers(doc.filename, true)
  if #active_servers > 0 then
    -- mark as lsp closed since GC can take some time to kick-in
    doc.lsp_open = false
    for _, name in pairs(active_servers) do
      local server = lsp.servers_running[name]
      if server.capabilities.textDocumentSync.openClose then
        server:push_notification('textDocument/didClose', {
          params = {
            textDocument = {
              uri = util.touri(core.project_absolute_path(doc.filename)),
              languageId = server:get_language_id(doc),
              version = doc.clean_change_id
            }
          }
        })
      end
    end
  end
end

--- Helper for lsp.update_document
---@param doc core.doc
local function request_signature_completion(doc)
  local line1, col1, line2, col2 = doc:get_selection()

  if line1 == line2 and col1 == col2 then
    -- First try to display a function signatures and if not possible
    -- do normal code autocomplete
    lsp.request_signature(
      doc,
      line1,
      col1,
      false,
      lsp.request_completion
    )
  end
end

---Send document updates to applicable running LSP servers.
---@param doc core.doc
---@param request_completion? boolean
function lsp.update_document(doc, request_completion)
  if not doc.lsp_open or not doc.lsp_changes or util.table_empty(doc.lsp_changes) then
    return
  end

  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    local server = lsp.servers_running[name]
    if not doc.lsp_changes[server] or #doc.lsp_changes[server] <= 0 then
      goto continue
    end
    local sync_kind = server.capabilities.textDocumentSync.change
    if
      sync_kind ~= protocol.TextDocumentSyncKind.None
      and
      server:can_push() -- ensure we don't loose incremental changes
    then
      local completion_callback = nil
      if request_completion then
        completion_callback = function() request_signature_completion(doc) end
      end

      if
        sync_kind == protocol.TextDocumentSyncKind.Full
        and
        not server.incremental_changes
      then
        -- If sync should be done by sending full file content then lets do
        -- it raw which is faster for big files.
        local text = table.concat(doc.lines)
          :gsub('\\', '\\\\'):gsub("\n", "\\n"):gsub("\r", "\\r")
          :gsub("\t", "\\t"):gsub('"', '\\"'):gsub('\b', '\\b')
          :gsub('\f', '\\f')

        server:push_raw("textDocument/didChange", {
          overwrite = true,
          raw_data = '{\n'
          .. '"jsonrpc": "2.0",\n'
          .. '"method": "textDocument/didChange",\n'
          .. '"params": {\n'
          .. '"textDocument": {\n'
          .. '"uri": "'..util.touri(core.project_absolute_path(doc.filename))..'",\n'
          .. '"version": '..doc.lsp_version .. "\n"
          .. '},\n'
          .. '"contentChanges": [\n'
          .. '{"text": "'..text..'"}\n'
          .. "]\n"
          .. '}\n'
          .. '}\n',
          callback = function()
            doc.lsp_changes[server] = nil
            if completion_callback then
              completion_callback()
            end
          end
        })
      else
        lsp.servers_running[name]:push_notification('textDocument/didChange', {
          overwrite = true,
          params = {
            textDocument = {
              uri = util.touri(core.project_absolute_path(doc.filename)),
              version = doc.lsp_version,
            },
            contentChanges = doc.lsp_changes[server]
          },
          callback = function()
            doc.lsp_changes[server] = nil
            if completion_callback then
              completion_callback()
            end
          end
        })
      end
    end
    ::continue::
  end
end

--- Enable or disable diagnostic messages
function lsp.toggle_diagnostics()
  config.plugins.lsp.show_diagnostics = not config.plugins.lsp.show_diagnostics

  if not config.plugins.lsp.show_diagnostics then
    diagnostics.lintplus_clear_messages()
    core.log("[LSP] Diagnostics disabled")
  else
    diagnostics.lintplus_populate()
    core.log("[LSP] Diagnostics enabled")
  end
end

--- Send to applicable LSP servers a request for code completion
---@param opts? { on_empty: fun() }
function lsp.request_completion(doc, line, col, forced, opts)
  opts = opts or {}
  if lsp.in_trigger or not doc.lsp_open then
    if opts.on_empty then opts.on_empty(doc) end
    return
  end

  local pending = 0
  local has_results = false
  local empty_notified = false
  local function completion_empty()
    if pending <= 0 or empty_notified then return end
    pending = pending - 1
    if pending <= 0 and not has_results and opts.on_empty then
      empty_notified = true
      opts.on_empty(doc)
    end
  end

  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    local server = lsp.servers_running[name]
    if server.capabilities.completionProvider then
      local capabilities = lsp.servers_running[name].capabilities
      local char = doc:get_char(line, col-1)
      local trigger_char = false

      local request = get_buffer_position_params(doc, line, col)

      -- without providing context some language servers like the
      -- lua-language-server behave poorly and return garbage.
      if
        capabilities.completionProvider.triggerCharacters
        and
        #capabilities.completionProvider.triggerCharacters > 0
        and
        char:match("%p")
        and
        util.intable(char, capabilities.completionProvider.triggerCharacters)
      then
        request.context = {
          triggerKind = protocol.CompletionTriggerKind.TriggerCharacter,
          triggerCharacter = char
        }
        trigger_char = true;
      end

      if
        not trigger_char
        and
        not autocomplete.can_complete()
        and
        not forced
      then
        return false
      end

      pending = pending + 1
      local partial = { autocomplete.get_partial_symbol() }

      server:push_request('textDocument/completion', {
        params = request,
        overwrite = true,
        callback = function(server, response)
          lsp.user_typed = false

          -- don't autocomplete if caret position changed
          local cline, cchar = doc:get_selection()
          if cline ~= line or cchar ~= col then
            return
          end

          if server.verbose then
            server:log(
              "Completion response received."
            )
          end

          if not response or not response.result then
            completion_empty()
            return
          end

          local result = response.result
          ---@cast result lsp.protocol.CompletionList | lsp.protocol.CompletionItem[]
          local complete_result = true
          if result.isIncomplete then
            if server.verbose then
              core.log_quiet(
                "["..server.name.."] " .. "Completion list incomplete"
              )
            end
            complete_result = false
          end

          if not result.items or #result.items <= 0 then
            -- Workaround for some lsp servers that don't return results
            -- in the items property but instead on the results it self
            if #result > 0 then
              local items = result
              result = {items = items}
            else
              completion_empty()
              return
            end
          end

          local symbols = {
            name = lsp.servers_running[name].name,
            files = lsp.servers_running[name].file_patterns,
            items = {}
          }

          local symbol_count = 1
          for _, symbol in ipairs(result.items) do
            local label = symbol.label
              or (
                symbol.textEdit
                and symbol.textEdit.newText
                or symbol.insertText
              )

            local info = server.get_completion_item_kind(symbol.kind)

            local desc = symbol.detail or ""

            -- TODO: maybe we should give priority to insertText above
            if
              symbol.label and
              symbol.insertText and
              #symbol.label > #symbol.insertText
            then
              label = symbol.insertText
              if symbol.label ~= label then
                desc = symbol.label
              end
              if symbol.detail then
                desc = desc .. ": " .. symbol.detail
              end
            end

            if desc ~= "" then
              desc = desc .. "\n"
            end

            if
              type(symbol.documentation) == "table"
              and
              symbol.documentation.value
            then
              desc = desc .. "\n" .. symbol.documentation.value
            elseif symbol.documentation then
              desc = desc .. "\n" .. symbol.documentation
            end

            desc = desc:gsub("[%s\n]+$", "")
              :gsub("\n\n\n+", "\n\n")

            symbols.items[label] = {
              info = info,
              desc = desc,
              data = {
                server = server,
                completion_item = symbol,
                partial = partial,
                resolved = true
              },
              onselect = autocomplete_onselect
            }

            if
              server.capabilities.completionProvider.resolveProvider
              and
              not symbol.documentation
            then
              symbols.items[label].data.resolved = false
              symbols.items[label].onhover = autocomplete_onhover
            end

            symbol_count = symbol_count + 1
          end

          if trigger_char and complete_result then
            lsp.in_trigger = true
            autocomplete.complete(symbols, function()
              lsp.in_trigger = false
            end)
          else
            autocomplete.complete(symbols)
          end

          if autocomplete.is_open() then
            has_results = true
          else
            lsp.in_trigger = false
            completion_empty()
          end
        end
      })
    end
  end

  if pending == 0 and opts.on_empty then
    opts.on_empty(doc)
  end
end

--- Send to applicable LSP servers a request for info about a function
--- signatures and display them on a tooltip.
function lsp.request_signature(doc, line, col, forced, fallback)
  if not doc.lsp_open then return end

  local char = doc:get_char(line, col-1)
  local prev_char = doc:get_char(line, col-2) -- to support ', '
  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    local server = lsp.servers_running[name]
    if
      server.capabilities.signatureHelpProvider
      and
      (
        forced
        or
        (
          server.capabilities.signatureHelpProvider.triggerCharacters
          and
          #server.capabilities.signatureHelpProvider.triggerCharacters > 0
          and
          (
            util.intable(
              char, server.capabilities.signatureHelpProvider.triggerCharacters
            )
            or
            util.intable(
              prev_char,
              server.capabilities.signatureHelpProvider.triggerCharacters
            )
          )
        )
      )
    then
      server:push_request('textDocument/signatureHelp', {
        params = get_buffer_position_params(doc, line, col),
        overwrite = true,
        callback = function(server, response)
          -- don't show signature if caret position changed
          local cline, cchar = doc:get_selection()
          if cline ~= line or cchar ~= col then
            return
          end

          if
            response.result
            and
            response.result.signatures
            and
            #response.result.signatures > 0
          then
            ---@cast response.result lsp.protocol.SignatureHelp
            autocomplete.close()
            listbox.show_signatures(response.result)
            lsp.user_typed  = false
          elseif fallback then
            fallback(doc, line, col)
          end
        end
      })
      break
    elseif fallback then
      fallback(doc, line, col)
    end
  end
end

---@type core.node
local help_active_node = nil
---@type core.node
local help_bottom_node = nil
--- Sends a request to applicable LSP servers for information about the
--- symbol where the cursor is placed and shows it on a tooltip.
function lsp.request_hover(doc, line, col, in_tab)
  if not doc.lsp_open then return end

  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    local server = lsp.servers_running[name]
    if server.capabilities.hoverProvider then
      server:push_request('textDocument/hover', {
        params = get_buffer_position_params(doc, line, col),
        callback = function(server, response)
          if response.result and response.result.contents then
            ---@cast response.result lsp.protocol.Hover
            local content = response.result.contents
            local kind = nil
            local text = ""
            if type(content) == "table" then
              if content.value then
                text = content.value
                if content.kind then kind = content.kind end
              else
                local texts = {}
                for _, element in pairs(content) do
                  if type(element) == "string" then
                    table.insert(texts, element)
                  elseif type(element) == "table" and element.value then
                    table.insert(texts, element.value)
                    if not kind and element.kind then kind = element.kind end
                  end
                end
                text = table.concat(texts, "\n\n")
              end
            else -- content should be a string
              text = content
            end
            if text and #text > 0 then
              text = text:gsub("^[\n%s]+", ""):gsub("[\n%s]+$", "")
              if not in_tab then
                if kind == "markdown" then
                  listbox.show_markdown(text, { line = line, col = col })
                else
                  listbox.show_text(text, { line = line, col = col })
                end
              else
                local line1, col1 = translate.start_of_word(doc, line, col)
                local line2, col2 = translate.end_of_word(doc, line1, col1)
                local title = doc:get_text(line1, col1, line2, col2):gsub("%s*", "")
                title = "Help:" .. title .. ".md"
                local helpview = MarkdownView({
                  text = text,
                  title = title
                })
                helpview.context = "application"
                if
                  not help_bottom_node
                  or
                  (
                    #help_bottom_node.views == 1
                    and
                    not help_active_node:get_node_for_view(help_bottom_node.views[1])
                  )
                then
                  help_active_node = core.root_view:get_active_node_default()
                  help_bottom_node = help_active_node:split("down", helpview)
                else
                  help_bottom_node:add_view(helpview)
                end
              end
            end
          end
        end
      })
      break
    end
  end
end

--- Sends a request to applicable LSP servers for a symbol references
function lsp.request_references(doc, line, col)
  if not doc.lsp_open then return end

  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    local server = lsp.servers_running[name]
    if server.capabilities.hoverProvider then
      local request_params = get_buffer_position_params(doc, line, col)
      request_params.context = {includeDeclaration = true}
      server:push_request('textDocument/references', {
        params = request_params,
        callback = function(server, response)
          if response.result and #response.result > 0 then
            ---@cast response.result lsp.plugin.locationlist
            local references, reference_names = get_references_lists(response.result)
            core.command_view:enter("Filter References", {
              submit = function(text, item)
                if item then
                  local reference = references[item.name]
                    lsp.goto_location(reference)
                end
              end,
              suggest = function(text)
                local res = common.fuzzy_match(reference_names, text)
                for i, name in ipairs(res) do
                  local reference_info = util.split(name, "||")
                  res[i] = {
                    text = reference_info[1],
                    info = reference_info[2],
                    name = name
                  }
                end
                return res
              end
            })
          else
            core.log("[LSP] No references found.")
          end
        end
      })
      break
    end
    break
  end
end

---Sends a request to applicable LSP servers to retrieve the
---hierarchy of calls for the given function under the cursor.
function lsp.request_call_hierarchy(doc, line, col)
  if not doc.lsp_open then return end

  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    local server = lsp.servers_running[name]
    if server.capabilities.callHierarchyProvider then
      server:push_request('textDocument/prepareCallHierarchy', {
        params = get_buffer_position_params(doc, line, col),
        callback = function(server, response)
          if response.result and #response.result > 0 then
            -- TODO: Finish implement call hierarchy functionality
            return
          end
        end
      })
      return
    end
  end

  core.log("[LSP] Call hierarchy not supported.")
end

---Sends a request to applicable LSP servers to rename a symbol.
---@param doc core.doc
---@param line integer
---@param col integer
---@param new_name string
function lsp.request_symbol_rename(doc, line, col, new_name)
  if not doc.lsp_open then return end

  local servers_found = false
  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    servers_found = true
    local server = lsp.servers_running[name]
    if server.capabilities.renameProvider then
      local request_params = get_buffer_position_params(doc, line, col)
      request_params.newName = new_name
      server:push_request('textDocument/rename', {
        params = request_params,
        callback = function(server, response)
          if
            response.result
            and
            workspaceedit.has_text_document_changes(response.result)
          then
            ---@cast response.result lsp.protocol.WorkspaceEdit
            local rename_symbol = RenameSymbol(response.result)
            core.root_view:get_active_node_default():add_view(rename_symbol)
          else
            MessageBox.error("Symbol Renaming", "Could not process the request")
          end
        end
      })
      return
    end
  end

  if not servers_found then
    core.log("[LSP] " .. "No server ready or running")
  else
    core.log("[LSP] " .. "Symbols rename not supported")
  end
end

---Apply a workspace edit returned by a server.
---@param server lsp.server
---@param edit lsp.protocol.WorkspaceEdit
---@return boolean
function lsp.apply_workspace_edit(server, edit)
  return workspaceedit.apply_workspace_edit(server, edit)
end

---Execute a command returned by a code action.
---@param server lsp.server
---@param lsp_command lsp.protocol.Command
function lsp.execute_command(server, lsp_command)
  if not lsp_command or not lsp_command.command then return end
  if not server.capabilities.executeCommandProvider then
    core.warn("[LSP] Execute command not supported by %s.", server.name)
    return
  end

  server:push_request("workspace/executeCommand", {
    params = {
      command = lsp_command.command,
      arguments = lsp_command.arguments
    },
    callback = function(server, response)
      if response.error and response.error.message then
        core.error("[LSP] %s", response.error.message)
      elseif workspaceedit.is_workspace_edit(response.result) then
        ---@cast response.result lsp.protocol.WorkspaceEdit
        lsp.apply_workspace_edit(server, response.result)
      end
    end
  })
end

---Apply a selected code action.
---@param server lsp.server
---@param action lsp.plugin.codeaction
function lsp.apply_code_action(server, action)
  if action.disabled then
    core.warn("[LSP] Code action disabled: %s", action.disabled.reason)
    return
  end

  local provider = server.capabilities.codeActionProvider
  if
    type(provider) == "table"
    and provider.resolveProvider
    and not action._lsp_resolved
    and not action.edit
    and not action.command
  then
    server:push_request("codeAction/resolve", {
      params = action,
      callback = function(server, response)
        if response.error and response.error.message then
          core.error("[LSP] %s", response.error.message)
        elseif response.result then
          ---@cast response.result lsp.protocol.CodeAction
          response.result._lsp_resolved = true
          lsp.apply_code_action(server, response.result)
        end
      end
    })
    return
  end

  if action.edit then
    workspaceedit.apply_workspace_edit(server, action.edit)
  end

  if action.command then
    if type(action.command) == "table" then
      lsp.execute_command(server, action.command)
    elseif type(action.command) == "string" then
      ---@cast action lsp.protocol.Command
      lsp.execute_command(server, action)
    end
  end
end

local function show_code_actions(server, actions)
  local indexes, captions = {}, {}

  for index, action in ipairs(actions) do
    local caption = action.title
    if action.disabled then
      caption = caption .. " (disabled)"
    elseif action.isPreferred then
      caption = caption .. " (preferred)"
    end
    captions[index] = caption
    indexes[caption] = index
  end

  core.command_view:enter("Code Action", {
    submit = function(text, item)
      if item then
        lsp.apply_code_action(server, actions[item.index])
      end
    end,
    suggest = function(text)
      local res = common.fuzzy_match(captions, text)
      for i, name in ipairs(res) do
        local action = actions[indexes[name]]
        res[i] = {
          text = action.title,
          info = action.disabled and action.disabled.reason
            or action.kind
            or (type(action.command) == "string" and action.command)
            or (
              type(action.command) == "table"
              and action.command.command
            )
            or "",
          index = indexes[name]
        }
      end
      return res
    end
  })
end

---Sends a request to applicable LSP servers for code actions.
---@param doc core.doc
---@param line1 integer
---@param col1 integer
---@param line2 integer
---@param col2 integer
function lsp.request_code_actions(doc, line1, col1, line2, col2)
  if not doc.lsp_open then return end

  local servers_found = false
  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    servers_found = true
    local server = lsp.servers_running[name]
    if server.capabilities.codeActionProvider then
      local request_params = get_buffer_range_params(doc, line1, col1, line2, col2)
      request_params.context.diagnostics = get_code_action_diagnostics(
        doc, request_params.range
      )
      request_params.context.triggerKind = protocol.CodeActionTriggerKind.Invoked

      server:push_request("textDocument/codeAction", {
        params = request_params,
        callback = function(server, response)
          if response.error and response.error.message then
            core.error("[LSP] %s", response.error.message)
          elseif response.result and #response.result > 0 then
            ---@cast response.result lsp.plugin.codeaction[]
            show_code_actions(server, response.result)
          else
            core.log("[LSP] No code actions found.")
          end
        end
      })
      return
    end
  end

  if not servers_found then
    core.log("[LSP] " .. "No server ready or running")
  else
    core.log("[LSP] " .. "Code actions not supported")
  end
end

---Sends a request to applicable LSP servers to search for symbol on workspace.
---@param doc core.doc
---@param symbol string
function lsp.request_workspace_symbol(doc, symbol)
  if not doc.lsp_open then return end

  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    local server = lsp.servers_running[name]
    if server.capabilities.workspaceSymbolProvider then
      server:push_request('workspace/symbol', {
        params = {
          query = symbol,
          -- TODO: implement status notifications but seems not supported
          -- by tested lsp servers so far.
          -- workDoneToken = "some-identifier",
          -- partialResultToken = "some-other-identifier"
        },
        callback = function(server, response)
          if response.result and #response.result > 0 then
            ---@cast response.result lsp.protocol.WorkspaceSymbol[]
            local rs = SymbolResults(symbol)
            core.root_view:get_active_node_default():add_view(rs)
            for index, result in ipairs(response.result) do
              rs:add_result(result)
              if index % 100 == 0 then
                core.redraw = true
                rs.list:resize_to_parent()
                coroutine.yield()
              end
            end
            core.redraw = true
            rs.list:resize_to_parent()
            rs:stop_searching()
          else
            core.warn("No matching workspace symbols were found.")
          end
        end
      })
      break
    end
    break
  end
end

--- Request a list of symbols for the given document for easy document
-- navigation and displays them using core.command_view:enter()
function lsp.request_document_symbols(doc)
  if not doc.lsp_open then return end

  local servers_found = false
  local symbols_retrieved = false
  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    servers_found = true
    local server = lsp.servers_running[name]
    if server.capabilities.documentSymbolProvider then
      log(server, "Retrieving document symbols...")
      server:push_request('textDocument/documentSymbol', {
        params = {
          textDocument = {
            uri = util.touri(core.project_absolute_path(doc.filename)),
          }
        },
        callback = function(server, response)
          if response.result and response.result and #response.result > 0 then
            ---@cast response.result lsp.plugin.symbollist
            local symbols, symbol_names = get_symbol_lists(response.result)
            core.command_view:enter("Find Symbol", {
              submit = function(text, item)
                if item then
                  local symbol = symbols[item.name]
                  -- The lsp may return a location object with range
                  -- and uri inside of it or just range as part of
                  -- the symbol it self.
                  symbol = symbol.location and symbol.location or symbol
                  if not symbol.uri then
                    local line1, col1 = util.toselection(symbol.range, doc)
                    doc:set_selection(line1, col1, line1, col1)
                  else
                    lsp.goto_location(symbol)
                  end
                end
              end,
              suggest = function(text)
                local res = common.fuzzy_match(symbol_names, text)
                for i, name in ipairs(res) do
                  res[i] = {
                    text = util.split(name, "||")[1],
                    info = Server.get_symbol_kind(symbols[name].kind),
                    name = name
                  }
                end
                return res
              end
            })
          end
        end
      })
      symbols_retrieved = true
      break
    end
  end

  if not servers_found then
    core.log("[LSP] " .. "No server running")
  elseif not symbols_retrieved then
    core.log("[LSP] " .. "Document symbols not supported")
  end
end

--- Format current document if supported by one of the running lsp servers.
---@param doc core.doc
---@param on_save boolean Was triggered from Doc:save()
function lsp.request_document_format(doc, on_save)
  if not doc.lsp_open then return end

  local servers_found = false
  local format_executed = false
  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    servers_found = true
    local server = lsp.servers_running[name]
    if server.capabilities.documentFormattingProvider then
      local trim_trailing_whitespace = false
      local trim_newlines = false
      if type(config.plugins.trimwhitespace) == "table"
         and config.plugins.trimwhitespace.enabled
      then
        trim_trailing_whitespace = true
        trim_newlines = config.plugins.trimwhitespace.trim_empty_end_lines
      elseif config.plugins.trimwhitespace then -- Plugin enabled with true
        trim_trailing_whitespace = true
        trim_newlines = true
      end
      local indent_type, indent_size, indent_confirmed = doc:get_indent_info()
      if not indent_confirmed then
        indent_type, indent_size = config.tab_type, config.indent_size
      end
      if on_save then doc.lsp_formatting = true end
      server:push_request('textDocument/formatting', {
        params = {
          textDocument = {
            uri = util.touri(core.project_absolute_path(doc.filename)),
          },
          options = {
            tabSize = indent_size,
            insertSpaces = indent_type == "soft",
            trimTrailingWhitespace = trim_trailing_whitespace,
            insertFinalNewline = false,
            trimFinalNewlines = trim_newlines
          }
        },
        callback = function(server, response)
          if response.error and response.error.message then
            log(server, "Error formatting: " .. response.error.message)
          elseif response.result and #response.result > 0 then
            ---@cast response.result lsp.protocol.TextEdit[]
            workspaceedit.apply_text_edits(server, doc, response.result)
            log(server, "Formatted document")
            if on_save then
              doc:save(doc.filename, doc.abs_filename)
            end
          else
            log(server, "Formatting not required")
          end
          if on_save then doc.lsp_formatting = nil end
        end
      })
      format_executed = true
      break
    end
  end

  if not servers_found then
    core.log("[LSP] " .. "No server running")
  elseif not format_executed then
    core.log("[LSP] " .. "Formatting not supported")
  end
end

function lsp.view_document_diagnostics(doc)
  local diagnostic_messages = diagnostics.get(core.project_absolute_path(doc.filename))
  if not diagnostic_messages or #diagnostic_messages <= 0 then
    core.log("[LSP] %s", "No diagnostic messages found.")
    return
  end

  local diagnostic_labels = { "Error", "Warning", "Info", "Hint" }

  local indexes, captions = {}, {}
  for index, diagnostic in pairs(diagnostic_messages) do
    local line1, col1 = util.toselection(diagnostic.range)
    local label = diagnostic_labels[diagnostic.severity or protocol.DiagnosticSeverity.Error]
      .. ": " .. diagnostic.message .. " "
      .. tostring(line1) .. ":" .. tostring(col1)
    captions[index] = label
    indexes[label] = index
  end

  core.command_view:enter("Filter Diagnostics", {
    submit = function(text, item)
      if item then
        local diagnostic = diagnostic_messages[item.index]
        local line1, col1 = util.toselection(diagnostic.range, doc)
        doc:set_selection(line1, col1, line1, col1)
      end
    end,
    suggest = function(text)
      local res = common.fuzzy_match(captions, text)
      for i, name in ipairs(res) do
        local diagnostic = diagnostic_messages[indexes[name]]
        local line1, col1 = util.toselection(diagnostic.range)
        res[i] = {
          text = diagnostics.lintplus_kinds[diagnostic.severity or protocol.DiagnosticSeverity.Error]
            .. ": " .. diagnostic.message,
          info = tostring(line1) .. ":" .. tostring(col1),
          index = indexes[name]
        }
      end
      return res
    end
  })
end

function lsp.view_all_diagnostics()
  if diagnostics.count <= 0 then
    core.log("[LSP] %s", "No diagnostic messages found.")
    return
  end

  local captions = {}
  for _, diagnostic in ipairs(diagnostics.list) do
    table.insert(
      captions,
      core.normalize_to_project_dir(diagnostic.filename)
    )
  end

  core.command_view:enter("Filter Files", {
    submit = function(text, item)
      if item then
        core.root_view:open_doc(
          core.open_doc(
            common.home_expand(
              text
            )
          )
        )
      end
    end,
    suggest = function(text)
      local res = common.fuzzy_match(captions, text, true)
      for i, name in ipairs(res) do
        local diagnostics_count = diagnostics.get_messages_count(
          core.project_absolute_path(name)
        )
        res[i] = {
          text = name,
          info = "Messages: " .. diagnostics_count
        }
      end
      return res
    end
  })
end

--- Jumps to the definition or implementation of the symbol where the cursor
-- is placed if the LSP server supports it
function lsp.goto_symbol(doc, line, col, implementation)
  if not doc.lsp_open then return end

  local server
  for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
    server = lsp.servers_running[name]

    local method = ""
    if not implementation then
      if server.capabilities.definitionProvider then
        method = method .. "definition"
      elseif server.capabilities.declarationProvider then
        method = method .. "declaration"
      elseif server.capabilities.typeDefinitionProvider then
        method = method .. "typeDefinition"
      end
    else
      if server.capabilities.implementationProvider then
        method = method .. "implementation"
      end
    end

    if method ~= "" then
      -- Send document updates first
      lsp.update_document(doc)

      server:push_request("textDocument/" .. method, {
        params = get_buffer_position_params(doc, line, col),
        callback = function(server, response)
          local location = response.result
          ---@cast location lsp.server.locationresult | nil

          if not location or not location.uri and #location == 0 then
            core.log("[LSP] No %s found.", method)
            return
          end

          if not location.uri and #location > 1 then
            listbox.clear()
            for _, loc in pairs(location) do
              local preview, position = get_location_preview(loc)
              listbox.append {
                text = preview,
                info = position,
                location = loc
              }
            end
            listbox.show_list(nil, function(doc, item)
              lsp.goto_location(item.location)
            end)
          else
            if not location.uri then
              location = location[1]
            end
            lsp.goto_location(location)
          end
        end
      })

      -- a provider was found, exit the loop
      return
    end
  end

  if server then
    log(
      server,
      "Goto "
      .. (implementation and "implementation" or "definition")
      .. " not supported"
    )
    return
  end
end

--
-- Thread to process server requests and responses
-- without blocking entirely the editor.
--
core.add_background_thread(function()
  while true do
    local servers_running = false
    for _,server in pairs(lsp.servers_running) do
      -- Send raw data to server which is usually big and slow in a
      -- non blocking way by creating a coroutine just for it.
      if #server.raw_list > 0 then
        local raw_send = coroutine.create(function()
          server:process_raw()
        end)
        coroutine.resume(raw_send)
        while coroutine.status(raw_send) ~= "dead" do
          -- while sending raw request we only read from lsp to not
          -- conflict with the written raw data so remember no calls
          -- here to: server:process_client_responses()
          -- or server:process_notifications()
          server:process_errors(config.plugins.lsp.log_server_stderr)
          server:process_responses()
          coroutine.yield(0.001)
          coroutine.resume(raw_send)
        end
      end

      if not config.plugins.lsp.more_yielding then
        server:process_notifications()
        server:process_requests()
        server:process_responses()
        server:process_client_responses()
      else
        server:process_notifications()
        coroutine.yield()
        server:process_requests()
        coroutine.yield()
        server:process_responses()
        server:process_client_responses()
        coroutine.yield()
      end

      server:process_errors(config.plugins.lsp.log_server_stderr)

      servers_running = true
    end

    if servers_running then
      local wait = 1 / config.plugins.lsp.checks_per_second
      if not system.window_has_focus(core.window) then
        wait = 1
      elseif config.plugins.lsp.more_yielding then
        wait = 0
      end
      coroutine.yield(wait)
    else
      coroutine.yield(2)
    end
  end
end)

--
-- Events patching
--
local doc_load = Doc.load
local doc_save = Doc.save
local doc_on_close = Doc.on_close
local doc_raw_insert = Doc.raw_insert
local doc_raw_remove = Doc.raw_remove
local root_view_on_text_input = RootView.on_text_input
local root_view_on_mouse_moved = RootView.on_mouse_moved

function Doc:load(...)
  local res = doc_load(self, ...)
  -- skip new files
  if self.filename and config.plugins.lsp.autostart_server then
    diagnostics.lintplus_init_doc(self)
    core.add_background_thread(function()
      lsp.start_server(self.filename, core.root_project().path)
      lsp.open_document(self)
    end)
  end
  return res
end

function Doc:save(...)
  local old_filename = self.filename
  local res = doc_save(self, ...)
  if old_filename ~= self.filename then
    -- seems to be a new document so we send open notification
    diagnostics.lintplus_init_doc(self)
    lsp.open_document(self)
  else
    lsp.update_document(self)
    lsp.save_document(self)
    if config.plugins.lsp.request_format_on_save and not self.lsp_formatting then
      lsp.request_document_format(self, true)
    end
  end
  return res
end

function Doc:on_close()
  doc_on_close(self)

  -- skip new files
  if not self.filename then return end

  lsp.close_document(self)

  if not config.plugins.lsp.stop_unneeded_servers then
    return
  end

  -- Check if any running lsp servers is not needed anymore and stop it
  for name, server in pairs(lsp.servers_running) do
    local doc_found = false
    for _, docu in ipairs(core.docs) do
      if docu.filename then
        if common.match_pattern(docu.filename, server.file_patterns) then
          doc_found = true
          break
        end
      end
    end

    if not doc_found and not server.exit_timer then
      local t = Timer(server.quit_timeout * 1000, true)
      t.on_timer = function()
        server:exit()
        core.log("[LSP] stopped %s", name)
        lsp.servers_running = util.table_remove_key(lsp.servers_running, name)
      end
      t:start()
      server.exit_timer = t
    end
  end
end

local function add_change(self, text, line1, col1, line2, col2)
  if not self.lsp_changes then
    self.lsp_changes = {}
    self.lsp_version = 0
  end

  ---@type lsp.plugin.contentchange
  local change = { range = {}, text = text}
  change.range["start"] = {line = line1-1, character = col1-1}
  change.range["end"] = {line = line2-1, character = col2-1}

  for _, name in pairs(lsp.get_active_servers(self.filename, true)) do
    local server = lsp.servers_running[name]
    if not self.lsp_changes[server] then
      self.lsp_changes[server] = {}
    end
    table.insert(self.lsp_changes[server], change)
  end

  -- TODO: this should not be needed but changing documents rapidly causes this
  if type(self.lsp_version) ~= 'nil' then
    self.lsp_version = self.lsp_version + 1
  else
    self.lsp_version = 1
  end
end

function Doc:raw_insert(line, col, text, undo_stack, time)
  doc_raw_insert(self, line, col, text, undo_stack, time)

  -- skip new files
  if not self.filename then return end

  col = util.doc_utf8_to_utf16(self, line, col)

  if self.lsp_open then
    if not lsp.symbols_tree:is_visible() then self.lsp_symbols = nil end
    add_change(self, text, line, col, line, col)
    lsp.update_document(self)
  elseif #lsp.get_active_servers(self.filename, true) > 0 then
    add_change(self, text, line, col, line, col)
  end
end

function Doc:raw_remove(line1, col1, line2, col2, undo_stack, time)
  local lcol1 = util.doc_utf8_to_utf16(self, line1, col1)
  local lcol2 = util.doc_utf8_to_utf16(self, line2, col2)

  doc_raw_remove(self, line1, col1, line2, col2, undo_stack, time)

  -- skip new files
  if not self.filename then return end

  if self.lsp_open then
    if not lsp.symbols_tree:is_visible() then self.lsp_symbols = nil end
    add_change(self, "", line1, lcol1, line2, lcol2)
    lsp.update_document(self)
  elseif #lsp.get_active_servers(self.filename, true) > 0 then
    add_change(self, "", line1, lcol1, line2, lcol2)
  end
end

function RootView:on_text_input(text)
  root_view_on_text_input(self, text)

  -- this part should actually trigger after Doc:raw_insert and Doc:raw_remove
  -- so it is safe to trigger autocompletion from here.
  local av = get_active_docview()

  if av then
    lsp.user_typed = true
    lsp.update_document(av.doc, true)
  end
end

function RootView:on_mouse_moved(x, y, dx, dy)
  root_view_on_mouse_moved(self, x, y, dx, dy)

  if not config.plugins.lsp.mouse_hover then return end

  local av = get_active_docview()

  if av and av.doc.lsp_open then
    ---@type core.doc
    local doc = av.doc
    local line, col = av:resolve_screen_position(x, y)
    local line1, col1 = translate.start_of_word(doc, line, col)
    local line2, col2 = translate.end_of_word(doc, line1, col1)
    local text = doc:get_text(line1, col1, line2, col2):gsub("%s*", "")
    local lx1, ly = av:get_line_screen_position(line1, col1)
    local lx2 = av:get_line_screen_position(line1, col2)
    if
      col >= col1 and col <= col2
      and
      text ~= ""
      and
      x >= lx1 and x <= lx2
      and
      y >= ly and y <= (ly + av:get_line_height())
    then
      lsp.hover_timer:reset()

      if
        (
          lsp.hover_position.doc ~= doc
          or
          lsp.hover_position.line ~= line1
          or
          lsp.hover_position.col ~= col1
        )
        and
        (
          not contextmenu or not contextmenu.show_context_menu
        )
      then
        listbox.hide()

        lsp.hover_position.triggered = true
        lsp.hover_position.doc = doc
        lsp.hover_position.line = line1
        lsp.hover_position.col = col1

        if not lsp.hover_timer:running() then
          lsp.hover_timer:set_interval(config.plugins.lsp.mouse_hover_delay)
          lsp.hover_timer:start()
        end
      end
    else
      if lsp.hover_position.triggered then
        listbox.hide()
        lsp.hover_position.triggered = false
        lsp.hover_position.doc = nil
        lsp.hover_position.line = 0
        lsp.hover_position.col = 0
      end
      lsp.hover_timer:stop()
    end
  end
end

--
-- Add status view item to show document diagnostics count
--
core.status_view:add_item({
  predicate = function()
    local dv = get_active_docview()
    if dv then
      local filename = core.project_absolute_path(dv.doc.filename)
      local diagnostic_messages = diagnostics.get(filename)
      if diagnostic_messages and #diagnostic_messages > 0 then
        return true
      end
    end
    return false
  end,
  name = "lsp:diagnostics",
  alignment = StatusView.Item.RIGHT,
  get_item = function()
    local dv = get_active_docview()
    if dv then
      local filename = core.project_absolute_path(dv.doc.filename)
      local diagnostic_messages = diagnostics.get(filename)

      if diagnostic_messages and #diagnostic_messages > 0 then
        return {
          style.warn,
          style.icon_font, "!",
          style.font, " " .. tostring(#diagnostic_messages)
        }
      end
    end

    return {}
  end,
  command = "lsp:view-document-diagnostics",
  position = 1,
  tooltip = "LSP Diagnostics",
  separator = core.status_view.separator2
})

--
-- Register autocomplete icons
--
if autocomplete.add_icon then
  local autocomplete_icons = {
    { name = "Text",          color = "keyword",  icon = '' }, -- U+F77E
    { name = "Method",        color = "function", icon = '' }, -- U+F6A6
    { name = "Function",      color = "function", icon = '' }, -- U+F794
    { name = "Constructor",   color = "literal",  icon = '' }, -- U+F423
    { name = "Field",         color = "keyword2", icon = 'ﰠ' }, -- U+FC20
    { name = "Variable",      color = "keyword2", icon = '' }, -- U+F52A
    { name = "Class",         color = "literal",  icon = 'ﴯ' }, -- U+FD2F
    { name = "Interface",     color = "literal",  icon = '' }, -- U+F0E8
    { name = "Module",        color = "literal",  icon = '' }, -- U+F487
    { name = "Property",      color = "keyword2", icon = 'ﰠ' }, -- U+FC20
    { name = "Unit",          color = "number",   icon = '塞' }, -- U+F96C
    { name = "Value",         color = "string",   icon = '' }, -- U+F89F
    { name = "Enum",          color = "keyword2", icon = '' }, -- U+F15D
    { name = "Keyword",       color = "keyword",  icon = '' }, -- U+F80A
    { name = "Snippet",       color = "keyword",  icon = '' }, -- U+F44F
    { name = "Color",         color = "string",   icon = '' }, -- U+F8D7
    { name = "File",          color = "string",   icon = '' }, -- U+F718
    { name = "Reference",     color = "string",   icon = '' }, -- U+F706
    { name = "Folder",        color = "string",   icon = '' }, -- U+F74A
    { name = "EnumMember",    color = "number",   icon = '' }, -- U+F15D
    { name = "Constant",      color = "number",   icon = '' }, -- U+F8FE
    { name = "Struct",        color = "keyword2", icon = 'פּ' }, -- U+FB44
    { name = "Event",         color = "keyword",  icon = '' }, -- U+F0E7
    { name = "Operator",      color = "operator", icon = '' }, -- U+F694
    { name = "Unknown",       color = "keyword",  icon = '' }, -- U+F128
    { name = "TypeParameter", color = "literal",  icon = '' }  -- U+EA92
  }

  -- We add the font here to let it automatically scale by the scale plugin
  style.syntax_fonts["lsp_symbols"] = renderer.font.load(
    USERDIR .. "/plugins/lsp/fonts/symbols.ttf",
    15 * SCALE
  )

  for _, icon in ipairs(autocomplete_icons) do
    autocomplete.add_icon(
      icon.name, icon.icon, style.syntax_fonts["lsp_symbols"], icon.color
    )
  end
end

--
-- Add Symbols Tree
--
lsp.symbols_tree = SymbolsTree()
lsp.symbols_tree:hide()
lsp.symbols_tree:set_size(config.plugins.lsp.symbolstree_width, 100)
if config.plugins.lsp.symbolstree_visibility == "auto" then
  lsp.symbols_tree:set_auto_hide(true)
elseif config.plugins.lsp.symbolstree_visibility == "show" then
  lsp.symbols_tree:set_auto_hide(false)
  lsp.symbols_tree:show()
else
  lsp.symbols_tree:set_auto_hide(false)
  lsp.symbols_tree:hide()
end

local node = core.root_view:get_active_node()
node:split("right", lsp.symbols_tree, {x = true}, true)

--
-- Commands
--
local original_autocomplete_open = command.map["autocomplete:open"]

---@param doc core.doc
local function perform_original_autocomplete_open(doc)
  if not original_autocomplete_open then return false end
  local res = { original_autocomplete_open.predicate() }
  if table.remove(res, 1) then
    if doc and doc.disable_symbols then doc.disable_symbols = nil end
    autocomplete.close()
    original_autocomplete_open.perform(table.unpack(res))
    return true
  end
  return false
end

---@param doc core.doc
local function lsp_complete_with_fallback(doc)
  if doc.lsp_open then
    local line1, col1, line2, col2 = doc:get_selection()
    if line1 ~= line2 or col1 ~= col2 then
      perform_original_autocomplete_open(doc)
      return
    end
    doc.disable_symbols = true -- disable symbol parsing on autocomplete plugin
    lsp.request_completion(doc, line1, col1, true, {
      on_empty = perform_original_autocomplete_open
    })
  else
    perform_original_autocomplete_open(doc)
  end
end

command.add(
  function()
    local dv = get_active_docview()
    return dv ~= nil, dv and dv.doc or nil
  end, {

  ["autocomplete:open"] = lsp_complete_with_fallback,

  ["lsp:complete"] = lsp_complete_with_fallback,
})

command.add(
  function()
    local dv = get_active_docview()
    return dv ~= nil and dv.doc.lsp_open, dv and dv.doc or nil
  end, {

  ["lsp:goto-definition"] = function(doc)
    local line1, col1, line2 = doc:get_selection()
    if line1 == line2 then
      lsp.goto_symbol(doc, line1, col1)
    end
  end,

  ["lsp:goto-implementation"] = function(doc)
    local line1, col1, line2 = doc:get_selection()
    if line1 == line2 then
      lsp.goto_symbol(doc, line1, col1, true)
    end
  end,

  ["lsp:goto-definition-under-cursor"] = function()
    local doc, line, col = lsp.get_hovered_location(
      core.root_view.mouse.x, core.root_view.mouse.y
    )
    if doc then
      lsp.goto_symbol(doc, line, col)
    end
  end,

  ["lsp:goto-implementation-under-cursor"] = function()
    local doc, line, col = lsp.get_hovered_location(
      core.root_view.mouse.x, core.root_view.mouse.y
    )
    if doc then
      lsp.goto_symbol(doc, line, col, true)
    end
  end,

  ["lsp:show-signature"] = function(doc)
    local line1, col1, line2, col2 = doc:get_selection()
    if line1 == line2 and col1 == col2 then
      lsp.request_signature(doc, line1, col1, true)
    end
  end,

  ["lsp:show-symbol-info"] = function(doc)
    local line1, col1, line2 = doc:get_selection()
    if line1 == line2 then
      lsp.request_hover(doc, line1, col1)
    end
  end,

  ["lsp:show-symbol-info-in-tab"] = function(doc)
    local line1, col1, line2 = doc:get_selection()
    if line1 == line2 then
      lsp.request_hover(doc, line1, col1, true)
    end
  end,

  ["lsp:view-call-hierarchy"] = function(doc)
    local line1, col1, line2 = doc:get_selection()
    if line1 == line2 then
      lsp.request_call_hierarchy(doc, line1, col1)
    end
  end,

  ["lsp:code-action"] = function(doc)
    local line1, col1, line2, col2 = doc:get_selection()
    lsp.request_code_actions(doc, line1, col1, line2, col2)
  end,

  ["lsp:view-document-symbols"] = function(doc)
    lsp.request_document_symbols(doc)
  end,

  ["lsp:format-document"] = function(doc)
    lsp.request_document_format(doc)
  end,

  ["lsp:view-document-diagnostics"] = function(doc)
    lsp.view_document_diagnostics(doc)
  end,

  ["lsp:rename-symbol"] = function(doc)
    ---@type core.view[]
    local views = core.root_view.root_node:get_children()
    for _, view in ipairs(views) do
      if view:is(RenameSymbol) then
        MessageBox.warning(
          "Symbol Rename in Progress",
          "Please finish and close currently opened symbol rename procedure."
        )
        return
      end
    end
    local symbol = doc:get_text(doc:get_selection())
    local line1, col1, line2 = doc:get_selection()
    if #symbol > 0 and line1 == line2 then
      core.command_view:enter("New Symbol Name", {
        text = symbol,
        select_text = true,
        submit = function(new_name)
          lsp.request_symbol_rename(doc, line1, col1, new_name)
        end
      })
    else
      core.log("Please select a symbol on the document to rename.")
    end
  end,

  ["lsp:find-references"] = function(doc)
    local line1, col1, line2 = doc:get_selection()
    if line1 == line2 then
      lsp.request_references(doc, line1, col1)
    end
  end
})

command.add(nil, {
  ["lsp:view-all-diagnostics"] = function()
    lsp.view_all_diagnostics()
  end,

  ["lsp:find-workspace-symbol"] = function()
    local dv = get_active_docview()
    local doc = dv and dv.doc or nil
    local symbol = doc and doc:get_text(doc:get_selection()) or ""
    core.command_view:enter("Find Workspace Symbol", {
      text = symbol,
      submit = function(query)
        lsp.request_workspace_symbol(doc, query)
      end
    })
  end,

  ["lsp:toggle-diagnostics"] = function()
    if not diagnostics.lintplus_found then
      core.error("[LSP] Please install lintplus for diagnostics rendering.")
      return
    end
    lsp.toggle_diagnostics()
  end,

  ["lsp:toggle-symbols-tree"] = function()
    lsp.symbols_tree:set_auto_hide(false)
    lsp.symbols_tree:toggle_visible(true, false, true, {
      on_complete = function(widget)
        if widget:is_visible() then
          widget:clear_current_doc()
        else
          widget.items = {{name = "loading", label = "Loading..."}}
          widget.symbols_loaded = false
        end
      end
    })
  end,

  ["lsp:enable-symbols-tree-auto-hide"] = function()
    lsp.symbols_tree:set_auto_hide(true)
  end,

  ["lsp:stop-servers"] = function()
    lsp.stop_servers()
  end,

  ["lsp:start-servers"] = function()
    lsp.start_servers()
  end,

  ["lsp:restart-servers"] = function()
    lsp.stop_servers()
    lsp.start_servers()
  end
})

--
-- Default Keybindings
--
keymap.add {
  ["ctrl+space"]        = "lsp:complete",
  ["ctrl+shift+space"]  = "lsp:show-signature",
  ["alt+a"]             = "lsp:show-symbol-info",
  ["alt+shift+a"]       = "lsp:show-symbol-info-in-tab",
  ["alt+d"]             = "lsp:goto-definition",
  ["alt+shift+d"]       = "lsp:goto-implementation",
  ["alt+shift+1lclick"] = "lsp:goto-definition-under-cursor",
  ["ctrl+alt+shift+1lclick"] = "lsp:goto-implementation-under-cursor",
  ["alt+s"]             = "lsp:view-document-symbols",
  ["alt+shift+s"]       = "lsp:find-workspace-symbol",
  ["alt+f"]             = "lsp:find-references",
  ["alt+shift+f"]       = "lsp:format-document",
  ["alt+e"]             = "lsp:view-document-diagnostics",
  ["ctrl+alt+e"]        = "lsp:view-all-diagnostics",
  ["alt+shift+e"]       = "lsp:toggle-diagnostics",
  ["alt+shift+\\"]      = "lsp:toggle-symbols-tree",
  ["alt+shift+c"]       = "lsp:view-call-hierarchy",
  ["alt+c"]             = "lsp:code-action",
  ["alt+r"]             = "lsp:rename-symbol",
}

--
-- Register context menu items
--
core.add_thread(function()
  if config.plugins.cotextmenu or type(config.plugins.cotextmenu) == "nil" then
    contextmenu = require "plugins.contextmenu"

    local function lsp_predicate(_, _, also_in_symbol)
      local dv = get_active_docview()
      if dv then
        local doc = dv.doc

        if #lsp.get_active_servers(doc.filename, true) < 1 then
          return false
        elseif not also_in_symbol then
          return true
        end

        -- Make sure the cursor is place near a document symbol (word)
        local linem, colm = doc:get_selection()
        local linel, coll = doc:position_offset(linem, colm, translate.start_of_word)
        local liner, colr = doc:position_offset(linem, colm, translate.end_of_word)

        local word_left = doc:get_text(linel, coll, linem, colm)
        local word_right = doc:get_text(linem, colm, liner, colr)

        if #word_left > 0 or #word_right > 0 then
          return true
        end
      end
      return false
    end

    local function lsp_predicate_symbols()
      return lsp_predicate(nil, nil, true)
    end

    local function lsp_predicate_code_actions()
      local dv = get_active_docview()
      if not dv then return false end

      local doc = dv.doc
      for _, name in pairs(lsp.get_active_servers(doc.filename, true)) do
        local server = lsp.servers_running[name]
        if server.capabilities.codeActionProvider then
          local line1, col1, line2, col2 = doc:get_selection()
          if line1 == line2 and col1 == col2 then
            col1 = 1
            col2 = #(doc.lines[line1] or "") + 1
          end
          return has_code_action_diagnostics(doc, line1, col1, line2, col2)
        end
      end

      return false
    end

    contextmenu:register(lsp_predicate_symbols, {
      contextmenu.DIVIDER,
      { text = "Show Symbol Info",        command = "lsp:show-symbol-info" },
      { text = "Show Symbol Info in Tab", command = "lsp:show-symbol-info-in-tab" },
      { text = "Goto Definition",         command = "lsp:goto-definition" },
      { text = "Goto Implementation",     command = "lsp:goto-implementation" },
      { text = "Find References",         command = "lsp:find-references" },
      { text = "Rename",                  command = "lsp:rename-symbol" },
    })

    contextmenu:register(lsp_predicate_code_actions, {
      contextmenu.DIVIDER,
      { text = "Code Action",             command = "lsp:code-action" },
    })

    contextmenu:register(lsp_predicate, {
      contextmenu.DIVIDER,
      { text = "Document Symbols",       command = "lsp:view-document-symbols" },
      { text = "Document Diagnostics",   command = "lsp:view-document-diagnostics" },
      { text = "Toggle Diagnostics",     command = "lsp:toggle-diagnostics" },
      { text = "Format Document",        command = "lsp:format-document" },
    })

    local contextmenu_show = contextmenu.show
    function contextmenu:show(...)
      if lsp.hover_position.triggered then
        lsp.hover_timer:stop()
        listbox.hide()
        lsp.hover_position.triggered = false
        lsp.hover_position.doc = nil
      end
      return contextmenu_show(self, ...)
    end
  end
end)

return lsp