dotfiles/nvim/.config/nvim/lua/romanzy/keymaps.lua

--- @param mode string|string[]
--- @param lhs string|string[]
--- @param rhs string|function
--- @param opts? vim.keymap.set.Opts
local map = function(mode, lhs, rhs, opts)
    if type(lhs) == "table" then
        for _, cmd in ipairs(lhs) do
            vim.keymap.set(mode, cmd, rhs, opts)
        end
    else
        vim.keymap.set(mode, lhs, rhs, opts)
    end
end

local function telescope_picker(picker)
    return function()
        require("telescope.builtin")[picker]()
    end
end

map("n", "<leader><leader>r", ":source ~/.config/nvim/init.lua<CR>", { desc = "reload init.lua" })
map("n", "<leader><leader>h", telescope_picker("keymaps"), { desc = "show keymaps" })
map("n", "<leader>e", function()
    MiniFiles.open()
end, { desc = "open mini.files" })
map("n", "<leader>ff", telescope_picker("find_files"), { desc = "find files" })
map("n", "<leader>fg", telescope_picker("live_grep"), { desc = "live grep" })
map("n", "<leader>fb", telescope_picker("buffers"), { desc = "find buffers" })
map("n", "<leader>fh", telescope_picker("help_tags"), { desc = "help tags" })
map("n", "<leader>lg", "<Cmd>LazyGit<CR>", { desc = "open lazygit" })
map("n", "<leader>dv", "<Cmd>DiffviewOpen<CR>", { desc = "open diffview" })
map("n", "<leader>dc", "<Cmd>DiffviewClose<CR>", { desc = "close diffview" })
map("n", "<leader>tw", require("romanzy.custom.wrap").toggle, { desc = "toggle soft wrap" })
map("n", "<leader>ts", require("romanzy.custom.spell").toggle, { desc = "toggle spell checking" })
map("n", "<leader>th", function()
    MiniDiff.toggle_overlay()
end, { desc = "toggle hunk view" })

map("n", "<leader>sv", "<Cmd>vs<CR>", { desc = "split vertical" })
map("n", "<leader>sh", "<Cmd>sp<CR>", { desc = "split horizontal" })
map("n", "<leader>se", "<C-w>=", { desc = "equalize splits" })
map("n", "<leader>sc", "<C-w>c", { desc = "close split" })

map("n", "<leader>rh", "<Cmd>vertical resize -10<CR>", { desc = "make buffer narrower" })
map("n", "<leader>rl", "<Cmd>vertical resize +10<CR>", { desc = "make buffer wider" })
map("n", "<leader>rj", "<Cmd>resize -5<CR>", { desc = "make buffer shorter" })
map("n", "<leader>rk", "<Cmd>resize +5<CR>", { desc = "make buffer taller" })
map("n", "<leader>re", "<C-w>=", { desc = "equalize buffer sizes" })

map("n", "<leader>bp", "<Cmd>bprevious<CR>", { desc = "prev buffer" })
map("n", "<leader>bn", "<Cmd>bnext<CR>", { desc = "next buffer" })
map("n", "<leader>bd", "<Cmd>bdelete<CR>", { desc = "delete buffer" })
map("n", "<leader>bc", require("romanzy.custom.buffers").close_hidden, { desc = "close hidden buffers" })
map("n", "<leader>bf", telescope_picker("buffers"), { desc = "find buffers" })

map({ "n", "v" }, "<leader>y", '"+y', { desc = "yank to system clipboard" })
map("n", "<leader>Y", '"+Y', { desc = "yank line to system clipboard" })
map("n", "<leader>p", '"+p', { desc = "paste from system clipboard" })
map("n", "<leader>P", '"+P', { desc = "paste before from system clipboard" })

-- experimenting
map("t", { "\\\\", "<C-\\><C-\\>", "<C-Esc>", "\\<Esc>" }, "<C-\\><C-n>", { desc = "exit terminal" })

map("n", "<C-h>", "<C-w>h", { desc = "window left" })
map("n", "<C-j>", "<C-w>j", { desc = "window down" })
map("n", "<C-k>", "<C-w>k", { desc = "window up" })
map("n", "<C-l>", "<C-w>l", { desc = "window right" })
map("n", { "gR", "<F5>" }, "<Cmd>edit<CR>", { desc = "refresh current buffer" })

-- this is needed to disable refresh behavior for <C-l> for navigation
vim.api.nvim_create_autocmd("FileType", {
    pattern = "oil",
    callback = function(ev)
        map("n", "<C-h>", "<C-w>h", { buffer = ev.buf, desc = "window left" })
        map("n", "<C-j>", "<C-w>j", { buffer = ev.buf, desc = "window down" })
        map("n", "<C-k>", "<C-w>k", { buffer = ev.buf, desc = "window up" })
        map("n", "<C-l>", "<C-w>l", { buffer = ev.buf, desc = "window right" })
    end,
})

-- hjkl supremacy
map({ "n", "v", "i" }, { "<left>", "<right>", "<up>", "<down>" }, function()
    vim.notify('hjkl supremacy', vim.log.levels.ERROR)
end, { desc = "hjkl supremacy" })

local function rename_without_default()
    vim.ui.input({
        prompt = "New Name: ",
        scope = "cursor",
    }, function(input)
        if not input or input == "" then
            return
        end

        vim.lsp.buf.rename(input)
    end)
end

vim.api.nvim_create_autocmd("LspAttach", {
    -- defaults are:
    -- grn → Rename symbol
    -- gra → Code actions
    -- grr → Find references
    -- gri → Go to implementation
    -- grt → Go to type definition
    -- gO → Document symbols
    callback = function(ev)
        map("n", "gd", vim.lsp.buf.definition, { buffer = ev.buf, desc = "goto definition" })
        map("n", "gD", vim.lsp.buf.declaration, { buffer = ev.buf, desc = "goto declaration" })
        map("n", "gfr", vim.lsp.buf.references, { buffer = ev.buf, desc = "find references" })
        map("n", "grn", rename_without_default, { buffer = ev.buf, desc = "rename symbol (from empty)" })
        map("n", "grN", vim.lsp.buf.rename, { buffer = ev.buf, desc = "rename symbol (from current)" })

        map({ "n", "x" }, "<leader>ca", vim.lsp.buf.code_action, { buffer = ev.buf, desc = "code actions" })
        map("n", "<leader>cf", function()
            vim.lsp.buf.code_action({
                apply = true,
                context = {
                    only = { "quickfix" },
                },
            })
        end, { buffer = ev.buf, desc = "quick fixes" })
        map({ "n", "x" }, "<leader>cs", function()
            vim.lsp.buf.code_action({
                context = {
                    only = { "source" },
                },
            })
        end, { buffer = ev.buf, desc = "source actions" })
    end,
})

-- diagnostics
map("n", "<leader>xx", function()
    require("trouble").toggle({
        mode = "diagnostics",
        filter = {
            severity = {
                vim.diagnostic.severity.ERROR,
                vim.diagnostic.severity.WARN,
            },
        },
    })
end, { desc = "toggle project warnings and errors" })
map("n", "g.", vim.diagnostic.open_float, { desc = "line diagnostics" })
map("n", "gl", vim.diagnostic.setloclist, { desc = "diagnostic list" })

map("n", "]g", function()
    vim.diagnostic.jump({
        count = 1,
        severity = {
            min = vim.diagnostic.severity.WARN,
        },
    })
end, { desc = "next warning/error" })
map("n", "[g", function()
    vim.diagnostic.jump({
        count = -1,
        severity = {
            min = vim.diagnostic.severity.WARN,
        },
    })
end, { desc = "prev warning/error" })

map("n", "gld", vim.diagnostic.setloclist, { desc = "display diagnostic information" })
map("n", "<leader>ti", function()
    vim.diagnostic.config({ virtual_text = not vim.diagnostic.config().virtual_text })
end, { desc = "toggle inline diagnostics" })
map("n", "<leader>tv", function()
    vim.diagnostic.config({ virtual_lines = not vim.diagnostic.config().virtual_lines })
end, { desc = "toggle virtual diagnostics" })