local WORD_CHARS =
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"

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

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

local function style_popup(winid, bufnr, width)
    if
        not winid
        or winid <= 0
        or not vim.api.nvim_win_is_valid(winid)
        or vim.api.nvim_win_get_config(winid).relative == ""
    then
        return
    end
    local cfg = { border = "rounded" }
    if width then
        cfg.width = math.min(width, 80)
    end
    if bufnr and vim.api.nvim_buf_is_valid(bufnr) then
        vim.wo[winid].wrap = true
        vim.wo[winid].linebreak = true
        vim.wo[winid].conceallevel = 2
        pcall(vim.treesitter.start, bufnr, "markdown")
    end
    pcall(vim.api.nvim_win_set_config, winid, cfg)
end

local M = {}

function M.apply_capabilities(capabilities)
    capabilities.textDocument.completion.completionItem.snippetSupport = false
end

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
    provider.triggerCharacters = provider.triggerCharacters or {}
    if not provider._word_chars_added then
        provider._word_chars_added = 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)
            local signature = vim.tbl_get(
                item,
                "labelDetails",
                "description"
            ) or item.detail or ""
            return {
                abbr = item.label:match("[^(]+") or item.label,
                menu = "",
                kind = "",
                info = signature ~= ""
                        and fence(vim.bo[buf].filetype, signature)
                    or " ",
            }
        end,
    })
end

function M.setup()
    vim.api.nvim_create_autocmd("CompleteChanged", {
        group = GROUP,
        callback = function(ev)
            local cinfo = vim.fn.complete_info({
                "selected",
                "preview_winid",
                "preview_bufnr",
            })

            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
                or not client:supports_method(
                    vim.lsp.protocol.Methods.completionItem_resolve
                )
            then
                style_popup(cinfo.preview_winid, cinfo.preview_bufnr)
                return
            end

            local selected = cinfo.selected
            local word = completed.word
            client:request(
                vim.lsp.protocol.Methods.completionItem_resolve,
                lsp_item,
                function(err, result)
                    if err or not result then
                        return
                    end

                    local cur = vim.fn.complete_info({
                        "selected",
                        "completed",
                        "preview_winid",
                    })
                    if
                        cur.selected ~= selected
                        or (vim.tbl_get(cur, "completed", "word") or "")
                            ~= word
                    then
                        return
                    end

                    local signature = vim.tbl_get(
                        result,
                        "labelDetails",
                        "description"
                    ) or result.detail or ""
                    local doc = result.documentation
                    if type(doc) == "table" then
                        doc = doc.value
                    end
                    doc = doc or ""

                    local ft = vim.bo[ev.buf].filetype
                    local code_parts = {}
                    if result.additionalTextEdits then
                        for _, edit in ipairs(result.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
                        if
                            cur.preview_winid
                            and cur.preview_winid > 0
                            and vim.api.nvim_win_is_valid(cur.preview_winid)
                        then
                            pcall(
                                vim.api.nvim_win_close,
                                cur.preview_winid,
                                true
                            )
                        end
                        return
                    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, 80))
                        .. "\n"
                    local combined = table.concat(sections, sep)

                    local windata = vim.api.nvim__complete_set(selected, {
                        info = combined,
                    })
                    if windata then
                        style_popup(windata.winid, windata.bufnr, max_w)
                    end
                end,
                ev.buf
            )
        end,
    })
end

return M