local kind = require("lsp.kind")
local util = require("util")

local REQUEST_DEBOUNCE_MS = 100

--- Normalize an `itemDefaults.editRange` to a plain Range, since it may be
--- either `Range` or `{ insert: Range, replace: Range }`.
---@param edit_range table?
---@return table?
local function default_range(edit_range)
    if type(edit_range) ~= "table" then
        return nil
    end
    return edit_range.insert or (edit_range.start and edit_range) or nil
end

--- Normalize an item's `textEdit`, which may be `TextEdit` (has `range`) or
--- `InsertReplaceEdit` (has `insert`/`replace`).
---@param item lsp.CompletionItem
---@return table?
local function item_range(item)
    local te = item.textEdit
    if type(te) ~= "table" then
        return nil
    end
    return te.range or te.insert
end

---@param response table LSP response entry (as returned by buf_request_all)
---@return integer? character  0-indexed UTF-16 character where edit starts
local function response_edit_start(response)
    if not response.result or response.err or response.error then
        return nil
    end
    local defaults =
        default_range(vim.tbl_get(response.result, "itemDefaults", "editRange"))
    if defaults then
        return defaults.start.character
    end
    local items = response.result.items or response.result
    if type(items) ~= "table" then
        return nil
    end
    for _, item in ipairs(items) do
        local range = item_range(item)
        if range then
            return range.start.character
        end
    end
    return nil
end

---@param item lsp.CompletionItem
---@return string
local function item_word(item)
    local edit = item.textEdit
    if type(edit) == "table" and edit.newText then
        return edit.newText
    end
    return item.insertText or item.label
end

---@param items lsp.CompletionItem[]
---@param defaults? table
local function apply_defaults(items, defaults)
    if type(defaults) ~= "table" then
        return
    end
    local range = default_range(defaults.editRange)
    for _, item in ipairs(items) do
        item.commitCharacters = item.commitCharacters
            or defaults.commitCharacters
        item.data = item.data or defaults.data
        item.insertTextFormat = item.insertTextFormat
            or defaults.insertTextFormat
        item.insertTextMode = item.insertTextMode or defaults.insertTextMode
        if range and type(item.textEdit) ~= "table" then
            item.textEdit = {
                range = range,
                newText = item.textEditText or item.insertText or item.label,
            }
        end
    end
end

--- Transform raw LSP completion responses into Vim |complete()| items,
--- filtered by `base` and sorted by sortText/label.
---@param responses table  map of client_id -> response from buf_request_all
---@param base string
---@return table[]
local function build_items(responses, base)
    local entries = {}
    for client_id, response in pairs(responses) do
        if response.result and not (response.err or response.error) then
            local raw = response.result.items or response.result
            if type(raw) == "table" then
                apply_defaults(raw, response.result.itemDefaults)
                for _, item in ipairs(raw) do
                    entries[#entries + 1] =
                        { item = item, client_id = client_id }
                end
            end
        end
    end

    if base ~= "" then
        entries = vim.tbl_filter(function(entry)
            local key = entry.item.filterText or entry.item.label
            return vim.startswith(key, base)
        end, entries)
    end

    table.sort(entries, function(a, b)
        local ka = a.item.sortText or a.item.label
        local kb = b.item.sortText or b.item.label
        return ka < kb
    end)

    local result = {}
    for _, entry in ipairs(entries) do
        local item = entry.item
        local kind_icon, kind_hl = kind.get(item.kind)
        result[#result + 1] = {
            word = item_word(item),
            abbr = item.label:match("[^(]+") or item.label,
            menu = vim.tbl_get(item, "labelDetails", "detail") or "",
            kind = kind_icon,
            kind_hlgroup = kind_hl,
            -- non-empty so our CompleteChanged handler triggers resolve
            info = " ",
            icase = 1,
            dup = 1,
            empty = 1,
            user_data = {
                nvim = {
                    lsp = {
                        completion_item = item,
                        client_id = entry.client_id,
                    },
                },
            },
        }
    end
    return result
end

local function buffer_has_completion_client()
    return #vim.lsp.get_clients({
        bufnr = 0,
        method = vim.lsp.protocol.Methods.textDocument_completion,
    }) > 0
end

---@param char string
---@return boolean
local function is_trigger_char(char)
    local clients = vim.lsp.get_clients({
        bufnr = 0,
        method = vim.lsp.protocol.Methods.textDocument_completion,
    })
    for _, client in ipairs(clients) do
        local chars = vim.tbl_get(
            client,
            "server_capabilities",
            "completionProvider",
            "triggerCharacters"
        )
        if chars and vim.list_contains(chars, char) then
            return true
        end
    end
    return false
end

local function feed_omnifunc()
    if vim.fn.mode() ~= "i" or vim.fn.pumvisible() ~= 0 then
        return
    end
    vim.api.nvim_feedkeys(vim.keycode("<C-x><C-o>"), "n", false)
end

---@class ow.lsp.completion.Request
---@field private generation integer
---@field private phase ('awaiting' | 'ready' | 'done')?
---@field private result table?
---@field private cancel function?
local Request = {}
Request.__index = Request

---@return ow.lsp.completion.Request
function Request.new()
    return setmetatable({
        generation = 0,
        phase = nil,
        result = nil,
        cancel = nil,
    }, Request)
end

---@return boolean
function Request:is_awaiting()
    return self.phase == "awaiting"
end

---@return boolean
function Request:is_ready()
    return self.phase == "ready"
end

--- Cancel any in-flight LSP request and clear cached results.
function Request:discard()
    if self.cancel then
        pcall(self.cancel)
    end
    self.generation = self.generation + 1
    self.phase = nil
    self.result = nil
    self.cancel = nil
end

---@param trigger_kind integer
---@param trigger_char string?
function Request:dispatch(trigger_kind, trigger_char)
    self:discard()
    self.phase = "awaiting"
    local gen = self.generation
    local buf = vim.api.nvim_get_current_buf()
    local params = vim.lsp.util.make_position_params(0, "utf-16")
    ---@cast params lsp.CompletionParams
    params.context = {
        triggerKind = trigger_kind,
        triggerCharacter = trigger_char,
    }
    self.cancel = vim.lsp.buf_request_all(
        buf,
        vim.lsp.protocol.Methods.textDocument_completion,
        params,
        function(result)
            if self.generation ~= gen or self.phase ~= "awaiting" then
                return
            end
            self.phase = "ready"
            self.result = result
            feed_omnifunc()
        end
    )
end

--- Byte column where the cached LSP edits start, for |complete-functions|
--- `findstart == 1`. Falls back to the regex end of the word under cursor.
---@return integer
function Request:start_col()
    for _, response in pairs(self.result or {}) do
        local col = response_edit_start(response)
        if col then
            return col
        end
    end
    local line = vim.api.nvim_get_current_line()
    local cursor_col = vim.fn.col(".") - 1
    return vim.fn.match(line:sub(1, cursor_col), "\\k*$")
end

--- Build the Vim |complete()| items from the cached LSP results filtered by
--- `base`, and transition this request to the "done" phase. Subsequent
--- completion triggers will dispatch a fresh request.
---@param base string
---@return table[]
function Request:consume(base)
    local items = build_items(self.result or {}, base)
    self.phase = "done"
    return items
end

local request = Request.new()

local debounce = util.debounce(function(_, trigger_kind, char)
    if vim.fn.mode() ~= "i" then
        return
    end
    request:dispatch(trigger_kind, char)
end, REQUEST_DEBOUNCE_MS)

local M = {}

function M.on_insert_char_pre()
    local char = vim.v.char
    if char == "" then
        return
    end
    local is_word = char:match("[%w_]") ~= nil
    local is_trigger = not is_word and is_trigger_char(char)
    if not (is_word or is_trigger) then
        return
    end
    -- For word chars, let Vim's native in-place filtering handle things while
    -- the pum is already showing. Trigger chars always schedule a request
    -- because they change the completion context (e.g. member access).
    if is_word and vim.fn.pumvisible() ~= 0 then
        return
    end

    local kind_num = is_trigger
            and vim.lsp.protocol.CompletionTriggerKind.TriggerCharacter
        or vim.lsp.protocol.CompletionTriggerKind.Invoked
    debounce:call(nil, kind_num, is_trigger and char or nil)
end

-- Global entry point for Vim's 'omnifunc' option. Referenced via
-- `v:lua.ow_lsp_completion.omnifunc` from on_attach's `vim.bo.omnifunc`.
_G.ow_lsp_completion = _G.ow_lsp_completion or {}

--- Returns cached items without re-requesting, which is what lets Vim filter
--- the popup in-place on backspace.
---@param findstart 0 | 1
---@param base string
---@return integer | table
function _G.ow_lsp_completion.omnifunc(findstart, base)
    if not buffer_has_completion_client() or request:is_awaiting() then
        return findstart == 1 and -3 or {}
    end
    if not request:is_ready() then
        request:dispatch(vim.lsp.protocol.CompletionTriggerKind.Invoked)
        return findstart == 1 and -3 or {}
    end
    if findstart == 1 then
        return request:start_col()
    end
    return request:consume(base)
end

return M