nvim/lua/lsp/completion/popup.lua

local MAX_WIDTH = 80
local MAX_HEIGHT = 20
local HALF_HEIGHT = math.floor(MAX_HEIGHT / 2)

local NS = vim.api.nvim_create_namespace("ow.lsp.completion.popup")

---@class ow.lsp.completion.Pum
---@field row integer
---@field col integer
---@field width integer
---@field height integer
---@field scrollbar boolean

---@class ow.lsp.completion.PendingResolve
---@field client vim.lsp.Client
---@field id integer

---@param ft string
---@param text string
---@return string
local function fence(ft, text)
    return string.format("```%s\n%s\n```", ft, text)
end

---@param item lsp.CompletionItem
---@return string
local function signature_of(item)
    return item.detail or vim.tbl_get(item, "labelDetails", "description") or ""
end

---@param item lsp.CompletionItem
---@param ft string
---@return string? content
---@return integer? width
local function build_content(item, ft)
    local signature = signature_of(item)
    local doc = item.documentation
    if type(doc) == "table" then
        doc = doc.value
    end
    doc = doc or ""

    local code_parts = {}
    if item.additionalTextEdits then
        for _, edit in ipairs(item.additionalTextEdits) do
            local text = (edit.newText or ""):gsub("%s+$", "")
            if text ~= "" then
                table.insert(code_parts, fence(ft, text))
            end
        end
    end
    if signature ~= "" then
        table.insert(code_parts, fence(ft, signature))
    end

    local sections = {}
    if #code_parts > 0 then
        table.insert(sections, table.concat(code_parts, "\n\n"))
    end
    if doc ~= "" then
        table.insert(sections, doc)
    end
    if #sections == 0 then
        return nil, nil
    end

    local max_w = 0
    for _, s in ipairs(sections) do
        for _, line in ipairs(vim.split(s, "\n", { plain = true })) do
            max_w = math.max(max_w, vim.fn.strdisplaywidth(line))
        end
    end
    local sep = "\n" .. string.rep("─", math.min(max_w, MAX_WIDTH)) .. "\n"
    return table.concat(sections, sep), max_w
end

---@class ow.lsp.completion.Popup
---@field private winid integer?
---@field private bufnr integer?
---@field private pending ow.lsp.completion.PendingResolve?
local Popup = {}
Popup.__index = Popup

---@return ow.lsp.completion.Popup
function Popup.new()
    return setmetatable({
        winid = nil,
        bufnr = nil,
        pending = nil,
    }, Popup)
end

---@return boolean
function Popup:is_visible()
    return self.winid ~= nil and vim.api.nvim_win_is_valid(self.winid)
end

function Popup:close()
    self:cancel_pending()
    if self:is_visible() then
        vim.api.nvim_win_close(self.winid, true)
    end
    self.winid = nil
end

--- Build content for `item` and show, or close if there's nothing to render.
---@param item lsp.CompletionItem
---@param ft string
---@param pum ow.lsp.completion.Pum
function Popup:show(item, ft, pum)
    local content, width = build_content(item, ft)
    if content and width then
        self:render(content, pum, width)
    else
        self:close()
    end
end

--- Cancel any in-flight resolve, dispatch a fresh one for `item`, and on
--- response render the resolved popup. If the user moved the selection
--- before the response landed (word mismatch), do nothing.
---@param client vim.lsp.Client
---@param item lsp.CompletionItem
---@param ft string
---@param pum ow.lsp.completion.Pum
---@param word string
---@param buf integer
function Popup:dispatch_resolve(client, item, ft, pum, word, buf)
    self:cancel_pending()
    local _, request_id = client:request(
        vim.lsp.protocol.Methods.completionItem_resolve,
        item,
        function(err, result)
            self.pending = nil
            if err or not result then
                return
            end
            local cur = vim.fn.complete_info({ "completed" })
            if (vim.tbl_get(cur, "completed", "word") or "") ~= word then
                return
            end
            self:show(result, ft, pum)
        end,
        buf
    )
    if request_id then
        self.pending = { client = client, id = request_id }
    end
end

---@param direction string  single-line scroll keycode (<C-e> or <C-y>)
function Popup:scroll_line(direction)
    self:scroll(direction, 1)
end

---@param direction string
function Popup:scroll_half(direction)
    self:scroll(direction, HALF_HEIGHT)
end

---@param content string
---@param pum ow.lsp.completion.Pum
---@param width integer
function Popup:render(content, pum, width)
    self:ensure_buffer()
    local lines = vim.split(content, "\n", { plain = true })
    vim.api.nvim_buf_set_lines(self.bufnr, 0, -1, false, lines)

    vim.api.nvim_buf_clear_namespace(self.bufnr, NS, 0, -1)
    for i, line in ipairs(lines) do
        if line ~= "" and line:gsub("─", "") == "" then
            vim.api.nvim_buf_set_extmark(self.bufnr, NS, i - 1, 0, {
                end_row = i - 1,
                end_col = #line,
                hl_group = "FloatBorder",
                priority = 200,
            })
        end
    end

    width = math.min(width, MAX_WIDTH)
    local height = math.min(#lines, MAX_HEIGHT)

    local right_edge = pum.col + pum.width + (pum.scrollbar and 1 or 0)
    local right_space = vim.o.columns - right_edge
    local col
    if right_space >= width + 2 then
        col = right_edge
    else
        col = math.max(pum.col - width - 2, 0)
    end

    local cfg = {
        relative = "editor",
        row = pum.row,
        col = col,
        width = width,
        height = height,
        border = "rounded",
        focusable = false,
        style = "minimal",
    }

    if self:is_visible() then
        vim.api.nvim_win_set_config(self.winid, cfg)
    else
        cfg.noautocmd = true
        self.winid = vim.api.nvim_open_win(self.bufnr, false, cfg)
        vim.wo[self.winid].wrap = true
        vim.wo[self.winid].linebreak = true
        vim.wo[self.winid].conceallevel = 2
    end
    vim.api.nvim_win_set_cursor(self.winid, { 1, 0 })

    local actual = vim.api.nvim_win_text_height(self.winid, {
        max_height = MAX_HEIGHT,
    }).all
    if actual ~= height then
        vim.api.nvim_win_set_height(self.winid, actual)
    end

    self:update_indicators()
end

---@param direction string
---@param count integer
function Popup:scroll(direction, count)
    if not self:is_visible() then
        return
    end
    vim.api.nvim_win_call(self.winid, function()
        vim.cmd.normal({ args = { count .. direction }, bang = true })
    end)
    self:update_indicators()
end

function Popup:cancel_pending()
    if self.pending then
        self.pending.client:cancel_request(self.pending.id)
        self.pending = nil
    end
end

function Popup:ensure_buffer()
    if self.bufnr and vim.api.nvim_buf_is_valid(self.bufnr) then
        return
    end
    self.bufnr = vim.api.nvim_create_buf(false, true)
    vim.bo[self.bufnr].buftype = "nofile"
    vim.bo[self.bufnr].bufhidden = "hide"
    vim.bo[self.bufnr].swapfile = false
    -- Markdown parser may not be installed; fall back to no highlighting.
    pcall(vim.treesitter.start, self.bufnr, "markdown")
end

function Popup:update_indicators()
    if not self:is_visible() then
        return
    end

    local visible = vim.api.nvim_win_get_height(self.winid)
    local topline, botline = unpack(vim.api.nvim_win_call(self.winid, function()
        return { vim.fn.line("w0"), vim.fn.line("w$") }
    end))

    local display_topline = 1
    if topline > 1 then
        display_topline = vim.api.nvim_win_text_height(self.winid, {
            end_row = topline - 2,
        }).all + 1
    end
    local display_bot = display_topline + visible - 1

    local total = vim.api.nvim_win_text_height(self.winid, {
        max_height = display_bot + 1,
    }).all

    local has_above = display_topline > 1
    local has_below = display_bot < total
        and botline
            < vim.api.nvim_buf_line_count(vim.api.nvim_win_get_buf(self.winid))

    vim.api.nvim_win_set_config(self.winid, {
        title = has_above and { { "▲ ", "FloatBorder" } } or "",
        title_pos = has_above and "right" or nil,
        footer = has_below and { { "▼ ", "FloatBorder" } } or "",
        footer_pos = has_below and "right" or nil,
    })
end

return Popup