local WORD_CHARS =
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"

local MAX_WIDTH = 80
local MAX_HEIGHT = 20

local GROUP = vim.api.nvim_create_augroup("ow.lsp.completion", { clear = true })
local NS = vim.api.nvim_create_namespace("ow.lsp.completion")

---@type table<integer, true>
local word_chars_extended = {}

---@alias lsp.completion.Pum { row: integer, col: integer, width: integer, height: integer, scrollbar: boolean }

---@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

---@type { winid: integer?, bufnr: integer?, pending: { client: vim.lsp.Client, id: integer }? }
local popup = {
    winid = nil,
    bufnr = nil,
    pending = nil,
}

local function cancel_pending()
    if popup.pending then
        pcall(
            popup.pending.client.cancel_request,
            popup.pending.client,
            popup.pending.id
        )
        popup.pending = nil
    end
end

---@return integer bufnr
local function ensure_buffer()
    if not popup.bufnr or not vim.api.nvim_buf_is_valid(popup.bufnr) then
        popup.bufnr = vim.api.nvim_create_buf(false, true)
        vim.bo[popup.bufnr].buftype = "nofile"
        vim.bo[popup.bufnr].bufhidden = "hide"
        vim.bo[popup.bufnr].swapfile = false
        pcall(vim.treesitter.start, popup.bufnr, "markdown")
    end
    return popup.bufnr
end

local function update_indicators()
    if not popup.winid or not vim.api.nvim_win_is_valid(popup.winid) then
        return
    end
    local visible = vim.api.nvim_win_get_height(popup.winid)
    local topline, botline = unpack(vim.api.nvim_win_call(popup.winid, function()
        return { vim.fn.line("w0"), vim.fn.line("w$") }
    end))
    local ok_total, info_total =
        pcall(vim.api.nvim_win_text_height, popup.winid, {})
    local total = ok_total and info_total.all or visible

    local display_topline = 1
    if topline > 1 then
        local ok, info = pcall(vim.api.nvim_win_text_height, popup.winid, {
            end_row = topline - 2,
        })
        if ok then
            display_topline = (info.all or 0) + 1
        end
    end
    local display_bot = display_topline + visible - 1

    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(popup.winid)
    )
    pcall(vim.api.nvim_win_set_config, popup.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

local function close()
    cancel_pending()
    if popup.winid and vim.api.nvim_win_is_valid(popup.winid) then
        pcall(vim.api.nvim_win_close, popup.winid, true)
    end
    popup.winid = nil
end

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

    vim.api.nvim_buf_clear_namespace(bufnr, NS, 0, -1)
    for i, line in ipairs(lines) do
        if line ~= "" and line:gsub("─", "") == "" then
            vim.api.nvim_buf_set_extmark(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 popup.winid and vim.api.nvim_win_is_valid(popup.winid) then
        pcall(vim.api.nvim_win_set_config, popup.winid, cfg)
    else
        cfg.noautocmd = true
        popup.winid = vim.api.nvim_open_win(bufnr, false, cfg)
        vim.wo[popup.winid].wrap = true
        vim.wo[popup.winid].linebreak = true
        vim.wo[popup.winid].conceallevel = 2
    end
    pcall(vim.api.nvim_win_set_cursor, popup.winid, { 1, 0 })

    local ok, info = pcall(vim.api.nvim_win_text_height, popup.winid, {})
    if ok and info.all and info.all ~= height then
        pcall(
            vim.api.nvim_win_set_height,
            popup.winid,
            math.min(info.all, MAX_HEIGHT)
        )
    end

    update_indicators()
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

local M = {}

---@param capabilities lsp.ClientCapabilities
function M.apply_capabilities(capabilities)
    capabilities.textDocument.completion.completionItem.snippetSupport = false
end

---@param client vim.lsp.Client
---@param buf integer
function M.on_attach(client, buf)
    if
        not client:supports_method(
            vim.lsp.protocol.Methods.textDocument_completion
        )
    then
        return
    end

    local provider = client.server_capabilities.completionProvider
    if not provider then
        return
    end
    provider.triggerCharacters = provider.triggerCharacters or {}
    if not word_chars_extended[client.id] then
        word_chars_extended[client.id] = true
        for c in WORD_CHARS:gmatch(".") do
            table.insert(provider.triggerCharacters, c)
        end
    end

    vim.api.nvim_clear_autocmds({ group = GROUP, buffer = buf })
    vim.api.nvim_create_autocmd("TextChangedI", {
        buffer = buf,
        group = GROUP,
        callback = function()
            if vim.fn.pumvisible() ~= 0 then
                return
            end
            local col = vim.fn.col(".") - 1
            if col <= 0 then
                return
            end
            local char = vim.api.nvim_get_current_line():sub(col, col)
            if char:match("[%w_]") then
                vim.lsp.completion.get()
            end
        end,
    })

    vim.lsp.completion.enable(true, client.id, buf, {
        autotrigger = true,
        convert = function(item)
            return {
                abbr = item.label:match("[^(]+") or item.label,
                menu = "",
                kind = "",
                -- non-empty info blocks vim.lsp.completion's built-in
                -- resolve so our own CompleteChanged handler can run it
                info = " ",
            }
        end,
    })
end

function M.setup()
    vim.api.nvim_create_autocmd("CompleteChanged", {
        group = GROUP,
        callback = function(ev)
            local completed = vim.v.event.completed_item or {}
            local lsp_item = vim.tbl_get(
                completed,
                "user_data",
                "nvim",
                "lsp",
                "completion_item"
            )
            local client_id =
                vim.tbl_get(completed, "user_data", "nvim", "lsp", "client_id")
            local client = client_id and vim.lsp.get_client_by_id(client_id)

            if not lsp_item or not client then
                vim.schedule(close)
                return
            end

            local ft = vim.bo[ev.buf].filetype
            ---@type lsp.completion.Pum
            local pum = {
                row = vim.v.event.row,
                col = vim.v.event.col,
                width = vim.v.event.width,
                height = vim.v.event.height,
                scrollbar = vim.v.event.scrollbar,
            }

            local will_resolve = client:supports_method(
                vim.lsp.protocol.Methods.completionItem_resolve
            )

            if not will_resolve then
                local initial, width = build_content(lsp_item, ft)
                vim.schedule(function()
                    if initial and width then
                        show(initial, pum, width)
                    else
                        close()
                    end
                end)
                return
            end

            cancel_pending()
            local word = completed.word
            local _, request_id = client:request(
                vim.lsp.protocol.Methods.completionItem_resolve,
                lsp_item,
                function(err, result)
                    popup.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
                    local content, width = build_content(result, ft)
                    if content and width then
                        show(content, pum, width)
                    else
                        close()
                    end
                end,
                ev.buf
            )
            if request_id then
                popup.pending = { client = client, id = request_id }
            end
        end,
    })

    vim.api.nvim_create_autocmd({ "CompleteDonePre", "InsertLeave" }, {
        group = GROUP,
        callback = close,
    })

    ---@param key string
    ---@param direction string  single-line scroll keycode (<C-e> or <C-y>)
    ---@param count integer
    local function scroll_map(key, direction, count)
        vim.keymap.set("i", key, function()
            if popup.winid and vim.api.nvim_win_is_valid(popup.winid) then
                vim.schedule(function()
                    if
                        popup.winid
                        and vim.api.nvim_win_is_valid(popup.winid)
                    then
                        vim.api.nvim_win_call(popup.winid, function()
                            vim.cmd.normal({
                                args = { count .. direction },
                                bang = true,
                            })
                        end)
                        update_indicators()
                    end
                end)
                return ""
            end
            return key
        end, { expr = true, replace_keycodes = true })
    end
    local half = math.floor(MAX_HEIGHT / 2)
    scroll_map("<C-d>", vim.keycode("<C-e>"), half)
    scroll_map("<C-u>", vim.keycode("<C-y>"), half)
    scroll_map("<C-j>", vim.keycode("<C-e>"), 1)
    scroll_map("<C-k>", vim.keycode("<C-y>"), 1)
end

return M