local log = require("log")

local M = {}

M.os_name = vim.uv.os_uname().sysname

---@alias OutputStream "stdout" | "stderr" | "in_place"

---@class ow.FormatOptions
---@field buf? integer Buffer to apply formatting to
---@field cmd string[] Command to run. The following keywords get replaces by the specified values:
---                    * %file%         - path to the file for `buf`
---                    * %filename%     - name of the file for `buf`
---                    * %row_start%    - first row of selection
---                    * %row_end%      - last row of selection
---                    * %col_start%    - first column position of selection
---                    * %col_end%      - last column position of selection
---                    * %byte_start%   - byte count of first cell in selection
---                    * %byte_end%     - byte count of last cell in selection
---@field output? OutputStream What stream to use as the result. May be one of `stdout`, `stderr` or `in_place`.
---@field auto_indent? boolean Perform auto indent on formatted range
---@field only_selection? boolean Only send the selected lines to `stdin`
---@field ignore_ret? boolean Ignore non-zero return codes
---@field ignore_stderr? boolean Ignore stderr output when not using stderr for output
---@field env? table<string, string> Map of environment variables

--- Format buffer
---@param opts ow.FormatOptions
function M.format(opts)
    opts = {
        buf = opts.buf or vim.api.nvim_get_current_buf(),
        cmd = opts.cmd,
        output = opts.output or "stdout",
        auto_indent = opts.auto_indent,
        only_selection = opts.only_selection,
        ignore_ret = opts.ignore_ret,
        ignore_stderr = opts.ignore_stderr,
        env = opts.env,
    }

    local file = vim.api.nvim_buf_get_name(opts.buf)
    local filename = vim.fn.fnamemodify(file, ":t")

    local mode = vim.fn.mode()
    local is_visual = mode == "v" or mode == "V" or mode == ""

    -- All 1-indexed, inclusive
    local row_start, row_end
    local col_start, col_end
    if is_visual then
        row_start, col_start = unpack(vim.fn.getpos("v"), 2, 3)
        row_end, col_end = unpack(vim.fn.getpos("."), 2, 3)

        if
            row_start > row_end
            or (row_start == row_end and col_start > col_end)
        then
            row_start, row_end, col_start, col_end =
                row_end, row_start, col_end, col_start
        end

        if mode == "V" then
            col_start = 1
            col_end = #vim.api.nvim_buf_get_lines(
                opts.buf,
                row_end - 1,
                row_end,
                false
            )[1]
        end
    else
        row_start = 1
        col_start = 1
        row_end = vim.api.nvim_buf_line_count(opts.buf)
        col_end = #vim.api.nvim_buf_get_lines(
            opts.buf,
            row_end - 1,
            row_end,
            false
        )[1]
    end

    local byte_start = vim.api.nvim_buf_get_offset(opts.buf, row_start - 1)
        + col_start
        - 1
    local byte_end = vim.api.nvim_buf_get_offset(opts.buf, row_end - 1)
        + col_end

    local input
    if is_visual and opts.only_selection then
        input = vim.api.nvim_buf_get_text(
            opts.buf,
            row_start - 1,
            col_start - 1,
            row_end - 1,
            col_end,
            {}
        )
    else
        input = vim.api.nvim_buf_get_lines(opts.buf, 0, -1, false)
    end

    local tmp
    if opts.output == "in_place" then
        tmp = os.tmpname()
        vim.fn.writefile(input, tmp, "s")
        file = tmp
    end

    for i, arg in ipairs(opts.cmd) do
        arg = arg:gsub("%%file%%", file)
        arg = arg:gsub("%%filename%%", filename)
        if is_visual then
            arg = arg:gsub("%%row_start%%", row_start)
            arg = arg:gsub("%%row_end%%", row_end)
            arg = arg:gsub("%%col_start%%", col_start)
            arg = arg:gsub("%%col_end%%", col_end)
            arg = arg:gsub("%%byte_start%%", byte_start)
            arg = arg:gsub("%%byte_end%%", byte_end)
        end
        opts.cmd[i] = arg
    end

    local resp = vim.system(opts.cmd, {
        stdin = input,
        env = opts.env,
    }):wait()
    local stdout = resp.stdout or ""
    local stderr = resp.stderr or ""

    local tmp_out
    if tmp then
        local f = io.open(tmp, "r")
        if not f then
            return
        end
        tmp_out = f:read("*a")
        f:close()
        os.remove(tmp)
    end

    if
        (not opts.ignore_ret and resp.code ~= 0)
        or (opts.output ~= "stderr" and not opts.ignore_stderr and stderr ~= "")
    then
        local msg = ""
        if stderr ~= "" then
            msg = ":\n" .. stderr
        end

        log.error("Failed to format (%d)%s", resp.code, msg)
        return
    end

    local output = ""
    if opts.output == "stdout" then
        output = stdout
    elseif opts.output == "stderr" then
        output = stderr
    elseif opts.output == "in_place" then
        output = tmp_out or ""
    end
    output = output:gsub("%s+$", "")

    local old_lines = input
    local new_lines =
        vim.split(output:gsub("\r\n", "\n"), "\n", { plain = true })

    local diff = vim.text.diff(
        table.concat(old_lines, "\n"),
        table.concat(new_lines, "\n"),
        { result_type = "indices", algorithm = "histogram" }
    )

    if not diff or #diff == 0 then
        return
    end

    ---@type lsp.TextEdit[]
    local text_edits = {}

    ---@diagnostic disable-next-line: param-type-mismatch
    for _, hunk in ipairs(diff) do
        local old_start, old_count, new_start, new_count = unpack(hunk)

        local lines = {}
        for j = new_start, new_start + new_count - 1 do
            table.insert(lines, new_lines[j])
        end

        local new_text = table.concat(lines, "\n") .. "\n"
        if new_count == 0 then
            new_text = ""
        end

        local start_line = row_start - 1 + old_start - 1
        local end_line = row_start - 1 + old_start - 1 + old_count
        if old_count == 0 then
            -- Insertion: old_start means "after line N" (where N is 1-indexed),
            --            which equals the 0-indexed position old_start
            start_line = start_line + 1
            end_line = end_line + 1
        end

        table.insert(text_edits, {
            range = {
                start = {
                    line = start_line,
                    character = 0,
                },
                ["end"] = {
                    line = end_line,
                    character = 0,
                },
            },
            newText = new_text,
        })
    end

    local view = vim.fn.winsaveview()

    vim.lsp.util.apply_text_edits(text_edits, opts.buf, "utf-16")

    if opts.auto_indent then
        vim.api.nvim_cmd({
            cmd = "normal",
            args = { "==" },
            bang = true,
            range = {
                row_start,
                math.min(row_end, vim.api.nvim_buf_line_count(opts.buf)),
            },
        }, { output = false })
    end

    vim.fn.winrestview(view)
end

--- Check if `val` is a list of type `t` (if given)
---@param val any
---@param kt type
---@param vt type
---@return boolean
function M.is_map(val, kt, vt)
    if type(val) ~= "table" then
        return false
    end

    for k, v in pairs(val) do
        if type(k) ~= kt then
            return false
        end

        if type(v) ~= vt then
            return false
        end
    end

    return true
end

--- Check if `val` is a list of type `t` (if given)
---@param val any
---@param t? type
---@return boolean
function M.is_list(val, t)
    if not vim.islist(val) then
        return false
    end

    for k, v in pairs(val) do
        if type(k) ~= "number" then
            return false
        end

        if t and type(v) ~= t then
            return false
        end
    end

    return true
end

--- Check if `val` is a list of type `t` (if given), or nil
---@param val? any
---@param t? type
---@return boolean
function M.is_list_or_nil(val, t)
    if val == nil then
        return true
    else
        return M.is_list(val, t)
    end
end

---@class ow.Util.DebounceHandle
---@field cancel fun()
---@field flush fun()
---@field pending fun(): boolean
---@field close fun()

---@generic F: fun(...)
---@param fn F
---@param delay integer
---@return F, ow.Util.DebounceHandle
function M.debounce(fn, delay)
    local timer, err = vim.uv.new_timer()
    if not timer then
        M.warning("debounce: failed to create timer: %s", err)
        local noop = function() end
        return fn,
            {
                cancel = noop,
                flush = noop,
                pending = function()
                    return false
                end,
                close = noop,
            }
    end
    local args ---@type table?
    local gen = 0
    local fired_gen = 0

    local cb_main = vim.schedule_wrap(function()
        -- Identity check: the libuv fire may have been superseded by a
        -- re-arm or a cancel between the timer firing and this scheduled
        -- callback running.
        if fired_gen ~= gen or args == nil then
            return
        end
        local a = args
        args = nil
        fn(vim.F.unpack_len(a))
    end)

    local cb_uv = function()
        fired_gen = gen
        cb_main()
    end

    local function call(...)
        args = vim.F.pack_len(...)
        gen = gen + 1
        timer:start(delay, 0, cb_uv)
    end

    return call,
        {
            cancel = function()
                timer:stop()
                args = nil
            end,
            flush = function()
                if args == nil then
                    return
                end
                timer:stop()
                local a = args
                args = nil
                fn(vim.F.unpack_len(a))
            end,
            pending = function()
                return args ~= nil
            end,
            close = function()
                timer:stop()
                if not timer:is_closing() then
                    timer:close()
                end
                args = nil
            end,
        }
end

---@class ow.Util.KeyedDebounceHandle<K>
---@field cancel fun(key: K)
---@field flush fun(key: K)
---@field pending fun(key: K): boolean
---@field close fun()

---@generic K, F: fun(key: K, ...)
---@param fn F
---@param delay integer
---@return F, ow.Util.KeyedDebounceHandle<K>
function M.keyed_debounce(fn, delay)
    ---@type table<K, { call: fun(...), handle: ow.Util.DebounceHandle }>
    local slots = {}

    local function call(key, ...)
        local t = type(key)
        assert(
            t == "string" or t == "number" or t == "boolean",
            "key must be a primitive (string, number, boolean)"
        )
        local slot = slots[key]
        if not slot then
            local c, h = M.debounce(function(...)
                fn(key, ...)
            end, delay)
            slot = { call = c, handle = h }
            slots[key] = slot
        end
        slot.call(...)
    end

    return call,
        {
            cancel = function(key)
                local slot = slots[key]
                if slot then
                    slot.handle.close()
                    slots[key] = nil
                end
            end,
            flush = function(key)
                local slot = slots[key]
                if slot then
                    slot.handle.flush()
                end
            end,
            pending = function(key)
                local slot = slots[key]
                return slot ~= nil and slot.handle.pending()
            end,
            close = function()
                for _, slot in pairs(slots) do
                    slot.handle.close()
                end
                slots = {}
            end,
        }
end

function M.get_hl_source(name)
    local hl = vim.api.nvim_get_hl(0, { name = name })
    while hl.link do
        hl = vim.api.nvim_get_hl(0, { name = hl.link })
    end

    return hl
end

---Split a string on newlines, dropping the trailing empty element that an
---input ending in `\n` produces. Convenient for slicing subprocess stdout
---into a list of lines without a phantom blank at the end.
---@param content string
---@return string[]
function M.split_lines(content)
    local lines = vim.split(content, "\n", { plain = true, trimempty = false })
    if #lines > 0 and lines[#lines] == "" then
        table.remove(lines)
    end
    return lines
end

return M