return {
    "folke/which-key.nvim",

    init = function()
        local wk = require("which-key")
        wk.add({
            { "<A-j>", ":m .+1<cr>==", desc = "Move line down" },
            { "<A-k>", ":m .-2<cr>==", desc = "Move line up" },
            {
                mode = "v",
                { "<A-j>", ":m '>+1<CR>gv=gv", desc = "Move line down" },
                { "<A-k>", ":m '<-2<CR>gv=gv", desc = "Move line up" },
            },
            {
                mode = "i",
                { "<A-j>", "<Esc>:m .+1<CR>==gi", desc = "Move line down" },
                { "<A-k>", "<Esc>:m .-2<CR>==gi", desc = "Move line up" },
            },

            { "<c-\\>", "<cmd>Commander<cr>", desc = "Commander" },

            {
                "<C-p>",
                function()
                    local git_root = Snacks.git.get_root()
                    if git_root then
                        Snacks.picker.git_files()
                    else
                        Snacks.picker.files()
                    end
                end,
                desc = "Find git files"
            },

            { ",", group = "Search" },
            { ",p", ":lua Snacks.picker.files()<cr>", desc = "Files files" },
            { ",b", ":lua Snacks.picker.buffers()<cr>", desc = "Buffer List" },
            { ",q", ":lua Snacks.picker.qflist()<cr>", desc = "Quickfix" },
            { ",c", ":lua Snacks.picker.command_history()<cr>", desc = "Quickfix" },
            { ",e", ":e **/*<C-z><S-Tab>", desc = "Open with autocomplete" },
            { ",f", ":find **/*<C-z><S-Tab>", desc = "Find with autocomplete" },

            { "<leader>p", group = "Search" },
            { "<leader>pc", ":lua Snacks.picker.git_log()<cr>", desc = "Git commits" },
            { "<leader>pf", ":lua Snacks.picker.git_log_file()<cr>", desc = "Git file history" },
            { "<leader>pb", ":lua Snacks.picker.git_branches()<cr>", desc = "Git branches" },
            { "<leader>ph", ":lua Snacks.picker.git_status()<cr>", desc = "Git status" },
            {
                "<leader>ps",
                ":lua Snacks.picker.grep()<cr>",
                desc = "Project search"
            },
            {
                "<leader>pr",
                ":lua Snacks.picker.resume()<cr>",
                desc = "Picker: resume"
            },

            {
                "<leader>ds",
                function()
                    local function pick_cmd_result(picker_opts)
                        local function finder(opts, ctx)
                            return require("snacks.picker.source.proc").proc({
                                opts,
                                {
                                    cmd = picker_opts.cmd,
                                    args = picker_opts.args,
                                    transform = function(item)
                                        -- item.cwd = picker_opts.cwd or git_root
                                        item.file = item.text
                                    end,
                                },
                            }, ctx)
                        end

                        Snacks.picker.pick {
                            source = picker_opts.name,
                            finder = finder,
                            preview = picker_opts.preview,
                            title = picker_opts.title,
                        }
                    end

                    local custom_pickers = {}

                    function custom_pickers.nvim()
                        pick_cmd_result {
                            cmd = "fd",
                            args = { ".", vim.fn.stdpath('config'), "--type", "f" },
                            name = "nvim config",
                            title = "Nvim config",
                            preview = "file",
                        }
                    end

                    custom_pickers.nvim()
                end,
                desc = "Search dot files 🔭",
            },
            {
                "<leader>R",
                desc = "Kulala HTTP",
            },
            {
                "<leader>R,",
                ":lua Snacks.picker.files({ft='http'})<cr>",
                desc = "Search request files",
            },

            { "K", "<cmd>Lspsaga hover_doc<cr>", desc = "Show documentation" },
            { "<C-k>", "<cmd>Lspsaga hover_doc ++keep<cr>", desc = "Show documentation (keep)" },
            { "grn", "<cmd>Lspsaga rename<cr>", desc = "Rename variable" },
            { "g", group = "Go to" },
            { "gd", ":Lspsaga goto_definition<cr>", desc = "Go to definition" },
            {
                "gD",
                function()
                    vim.lsp.buf.declaration()
                end,
                desc = "Go to declaration",
            },
            { "gt", ":Lspsaga goto_type_definition<cr>", desc = "Go to type definition" },
            { "gh", ":Lspsaga finder<cr>", desc = "LSP Finder" },
            { "gH", ":Lspsaga finder ++normal<cr>", desc = "LSP Finder (keep)" },
            { "<localleader>a", group = "Local File Actions" },
            { "gra", mode = { "n", "v" }, "<cmd>Lspsaga code_action<cr>", desc = "Code action" },
            {
                "<localleader>ag",
                function()
                    vim.diagnostic.open_float(0,
                        { scope = "line", focusable = false })
                end,
                desc = "Show line diagnostics",
            },
            {
                "grp",
                function()
                    require("overlook.api").peek_definition()
                end,
                desc = "Peek",
            },
            {
                "grd",
                "<cmd>Glance definitions<cr>",
                desc = "Definitions",
            },
            {
                "grr",
                "<cmd>Glance references<cr>",
                desc = "References",
            },
            {
                "gri",
                "<cmd>Glance implementations<cr>",
                desc = "Implementations",
            },
            {
                "grt",
                "<cmd>Glance type_definitions<cr>",
                desc = "Type definitions",
            },
            {
                "grI",
                "<cmd>Lspsaga incoming_calls<cr>",
                desc = "Incoming calls",
            },
            {
                "grO",
                "<cmd>Lspsaga outgoing_calls<cr>",
                desc = "Outgoing calls",
            },

            {
                "gO",
                "<cmd>Lspsaga outline<cr>",
                desc = "Toggle Outline",
                icon = "󰷐",
            },

            {
                "<leader>g",
                group = "Git",
            },
            {
                "<leader>gs",
                "<cmd>Neogit<cr>",
                desc = "Git status (Neogit)",
            },
            {
                "<leader>gd",
                "<cmd>DiffviewOpen<cr>",
                desc = "Diff view",
            },
            {
                "<leader>gl",
                function()
                    require("neogit").action("log", "log_current")()
                end,
                desc = "Git log",
            },
            {
                "<leader>gf",
                "<cmd>Neogit<cr>",
                desc = "Git diff current file",
            },

            {
                "<leader>T",
                group = "Tabs"
            },
            {
                "<leader>TT",
                "<cmd>tabs<CR>",
                desc = "Tabs list"
            },
            {
                "<leader>Tn",
                "<cmd>tabnext<CR>",
                desc = "Next Tab"
            },
            {
                "<leader>Tp",
                "<cmd>tabprevious<CR>",
                desc = "Previous Tab"
            },
            {
                "<leader>Tf",
                "<cmd>tabfirst<CR>",
                desc = "First Tab"
            },
            {
                "<leader>Tl",
                "<cmd>tablast<CR>",
                desc = "Last Tab"
            },
            {
                "<leader>TN",
                "<cmd>tabnew<CR>",
                desc = "New Tab"
            },
            {
                "<leader>Tc",
                "<cmd>tabclose<CR>",
                desc = "Close Tab"
            },
            {
                "»",
                "]",
                noremap = false,
            },
            {
                "«",
                "[",
                noremap = false,
            },
            { "<localleader>g", group = "git signs" },
            {
                "<localleader>gs",
                function()
                    require("gitsigns").stage_hunk()
                end,
                desc = "Stage hunk",
            },
            {
                "<localleader>gu",
                function()
                    require("gitsigns").undo_stage_hunk()
                end,
                desc = "Undo stage hunk",
            },
            {
                "<localleader>gv",
                function()
                    require("gitsigns").preview_hunk()
                end,
                desc = "Preview hunk",
            },
            {
                "<localleader>gb",
                function()
                    require("gitsigns").blame_line()
                end,
                desc = "Blame line",
            },
            {
                "<localleader>gB",
                function()
                    require("gitsigns").blame()
                end,
                desc = "Blame line",
            },
            {
                "<localleader>gR",
                function()
                    require("gitsigns").reset_buffer()
                end,
                desc = "Reset buffer",
            },
            {
                "<localleader>gr",
                function()
                    require("gitsigns").reset_hunk()
                end,
                desc = "Reset hunk",
            },
            {
                "<localleader>gS",
                function()
                    require("gitsigns").stage_buffer()
                end,
                desc = "Stage buffer",
            },
            {
                "<localleader>gU",
                function()
                    require("gitsigns").reset_buffer_index()
                end,
                desc = "Reset buffer index",
            },
            {
                mode = "v",
                {
                    "<localleader>gs",
                    function()
                        require("gitsigns").stage_hunk({ vim.fn.line("."),
                            vim.fn.line("v") })
                    end,
                    desc = "Stage hunk",
                },
                {
                    "<localleader>gr",
                    function()
                        require("gitsigns").reset_hunk({ vim.fn.line("."),
                            vim.fn.line("v") })
                    end,
                    desc = "Reset hunk",
                },
            },

            {
                "]c",
                function()
                    if vim.wo.diff then
                        vim.cmd.normal({ "]c", bang = true })
                    else
                        vim.schedule(function()
                            require("gitsigns").nav_hunk("next")
                        end)
                    end
                end,
                desc = "Next hunk",
            },
            {
                "[c",
                function()
                    if vim.wo.diff then
                        vim.cmd.normal({ "[c", bang = true })
                    else
                        vim.schedule(function()
                            require("gitsigns").nav_hunk("prev")
                        end)
                    end
                end,
                desc = "Previous hunk",
            },

            { "<leader>u", "<cmd>UndotreeToggle<cr>", desc = "Undotree", icon = "" },

            { "<leader>c", group = "quickfix" },
            { "<leader>co", "<cmd>copen<cr>", desc = "Open" },
            { "<leader>cc", "<cmd>cclose<cr>", desc = "Close" },

            { "<localleader>c", group = "Location List" },
            { "<localleader>co", "<cmd>lopen<cr>", desc = "Open" },
            { "<localleader>cc", "<cmd>lclose<cr>", desc = "Close" },

            { "<C-n>", "<cmd>Neotree toggle<cr>", desc = "Toggle neo-tree" },

            { "<leader>t", "<cmd>lua Snacks.terminal.toggle()<cr>", desc = "Toggle Terminal" },
            { mode = { "t" }, { "<leader>t", "<cmd>lua Snacks.terminal.toggle()<cr>", desc = "Toggle Terminal" } },

            {
                mode = { "n", "x", "o" },
                {
                    "s",
                    function()
                        require("flash").jump()
                    end,
                    desc = "Flash ⚡",
                },
                {
                    "S",
                    function()
                        require("flash").treesitter()
                    end,
                    desc = "Flash Treesitter ⚡",
                },
            },
            {
                mode = { "o", "x" },
                {
                    "R",
                    function()
                        require("flash").treesitter_search()
                    end,
                    desc = "Flash Treesitter search ⚡",
                },
            },
            {
                mode = "o",
                {
                    "r",
                    function()
                        -- https://www.lorenzobettini.it/2025/05/using-flash-remote-in-neovim/
                        require("flash").remote()
                    end,
                    desc = "Flash remote ⚡",
                },
            },
            {
                mode = "c",
                {
                    "<C-s>",
                    function()
                        require("flash").toggle()
                    end,
                    desc = "Toggle Flash Search ⚡",
                },
            },
        })
    end,
}