-- The MIT License (MIT)
--
-- Copyright © 2026 Scott E. Graves <scott.e.graves@protonmail.com>
--
-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software
-- and associated documentation files (the “Software”), to deal in the Software without restriction,
-- including without limitation the rights to use, copy, modify, merge, publish, distribute,
-- sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-- furnished to do so, subject to the following conditions:
--
-- The above copyright notice and this permission notice shall be included in all copies or
-- substantial portions of the Software.
--
-- THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
-- BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-- DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--
local M = {}

require("darcula.utils.string")

local km = require("darcula.utils.keymap")
local telescope_builtin = require("telescope.builtin")
local utils = require("darcula.utils")
local utils_ui = require("darcula.utils.ui")

if NV_DARCULA_ENABLE_COC then
  local coc_command = function(command)
    vim.cmd("CocCommand " .. command)
  end

  local telescope_coc_command = function(command)
    vim.cmd("Telescope coc " .. command)
  end

  function M.coc()
    local opts = {remap = true, silent = true}
    km.vmap(
      km.leader "gs",
      function()
        vim.cmd("CocSearch -F " .. vim.fn.escape(utils.get_visual_text(), " "))
      end,
      opts
    )

    km.nmap(
      km.leader "gs",
      function()
        vim.cmd("CocSearch -F " .. vim.fn.escape(utils.cword(), " "))
      end,
      opts
    )

    opts = {expr = true, nowait = true, remap = false, silent = true}

    km.set(
      "i",
      "<C-Space>",
      function()
        vim.fn.CocActionAsync("showSignatureHelp")
      end,
      opts
    )

    km.map(
      km.leader "ii",
      function()
        vim.cmd("CocInfo")
      end,
      {remap = false, silent = true}
    )

    km.map(
      km.leader "is",
      function()
        vim.notify(
          utils.iff(
            vim.g.coc_status ~= nil and #vim.g.coc_status > 0,
            vim.g.coc_status,
            "None"
          ),
          vim.log.levels.INFO
        )
      end,
      {remap = false, silent = true}
    )

    km.set(
      {"n", "v"},
      "<C-f>",
      function()
        return NV_Darcula_Coc_Float_Scroll(true)
      end,
      opts
    )

    km.set(
      {"n", "v"},
      "<C-b>",
      function()
        return NV_Darcula_Coc_Float_Scroll(false)
      end,
      opts
    )

    km.imap(
      "<C-f>",
      function()
        return NV_Darcula_Coc_Float_Scroll_Insert_Mode(true)
      end,
      opts
    )

    km.imap(
      "<C-b>",
      function()
        return NV_Darcula_Coc_Float_Scroll_Insert_Mode(false)
      end,
      opts
    )

    km.imap(
      "<bs>",
      function()
        if vim.bo.buftype ~= "nofile" and vim.fn["coc#pum#visible"]() ~= 0 then
          return "<bs><c-r>=coc#start()<cr>"
        end
        return "<bs>"
      end,
      {expr = true, remap = false, silent = true}
    )

    opts = {remap = true, silent = true}
    km.imap(
      "<S-Tab>",
      NV_Darcula_Coc_Shift_Tab_Complete,
      {remap = false, expr = true}
    )
    km.imap(
      "<Tab>",
      NV_Darcula_Coc_Tab_Complete,
      {remap = false, expr = true, silent = true}
    )
    km.imap(
      "<cr>",
      NV_Darcula_Coc_Completion_Confirm,
      {remap = false, silent = true, expr = true}
    )
    km.nmap(km.leader "cl", "<Plug>(coc-codelens-action)", opts)
    km.nmap(km.leader "gn", "<Plug>(coc-diagnostic-next)", opts)
    km.nmap(km.leader "gp", "<Plug>(coc-diagnostic-prev)", opts)
    km.nmap(km.leader "qf", "<Plug>(coc-fix-current)", opts)
    km.nmap(km.leader "rn", "<Plug>(coc-rename)", opts)
    km.xmap(km.leader "rs", "<Plug>(coc-range-select)", opts)
    km.set({"n", "v"}, km.leader "rs", "<Plug>(coc-range-select)", opts)
    km.set({"n", "x"}, km.leader "a", "<Plug>(coc-codeaction-selected)", opts)

    km.nmap(
      km.leader "ac",
      function()
        telescope_coc_command("code_actions")
      end,
      opts
    )

    km.nmap(
      km.leader "ca",
      function()
        telescope_coc_command("code_actions")
      end,
      opts
    )

    km.nmap(
      km.leader "dl",
      function()
        vim.cmd("CocDiagnostics")
      end,
      opts
    )

    km.nmap(
      km.leader "di",
      function()
        telescope_coc_command("diagnostics")
      end,
      opts
    )

    km.nmap(
      km.leader "dw",
      function()
        telescope_coc_command("workspace_diagnostics")
      end,
      opts
    )

    km.nmap(
      km.leader "fs",
      function()
        telescope_coc_command("document_symbols")
      end,
      opts
    )

    km.nmap(
      km.leader "fw",
      function()
        telescope_coc_command("workspace_symbols")
      end,
      opts
    )

    km.nmap(
      km.leader "gd",
      function()
        telescope_coc_command("definitions")
      end,
      opts
    )

    km.nmap(
      km.leader "gD",
      function()
        telescope_coc_command("declarations")
      end,
      opts
    )

    km.nmap(
      km.leader "gh",
      function()
        coc_command("clangd.switchSourceHeader")
      end,
      {silent = true, remap = false, nowait = true}
    )

    km.nmap(
      km.leader "gi",
      function()
        telescope_coc_command("implementations")
      end,
      opts
    )

    km.nmap(
      km.leader "gr",
      function()
        telescope_coc_command("references")
      end,
      opts
    )

    km.nmap(
      km.leader "gy",
      function()
        telescope_coc_command("type_definitions")
      end,
      opts
    )
  end
end

function M.commenting()
  local opts = {remap = true, silent = true}

  km.nmap(km.leader "ub", "gcc", opts)
  km.nmap(km.leader "uu", "gcc", opts)
  km.vmap(km.leader "ub", "gcc", opts)
  km.vmap(km.leader "uu", "gcc", opts)
end

function M.cppman()
  local opts = {silent = true}
  km.nmap(km.leader "dM", require("cppman").search, opts)
end

function M.cspell()
  local opts = {silent = true}

  km.nmap(km.leader2 "sc", NV_Darcula_Cspell_Cleanup, opts)

  km.nmap(
    km.leader2 "su",
    function()
      NV_Darcula_Cspell_Add_Word(true)
    end,
    opts
  )

  km.vmap(
    km.leader2 "su",
    function()
      NV_Darcula_Cspell_Add_Selected_Word(true)
    end,
    opts
  )

  km.nmap(
    km.leader2 "sw",
    function()
      NV_Darcula_Cspell_Add_Word(false)
    end,
    opts
  )

  km.vmap(
    km.leader2 "sw",
    function()
      NV_Darcula_Cspell_Add_Selected_Word(false)
    end,
    opts
  )
end

function M.diff()
  km.nmap(km.leader "dn", "]c", {remap = false})
  km.nmap(km.leader "do", ":diffoff<cr>", {silent = true, remap = false})
  km.nmap(km.leader "dp", "[c", {remap = false})
end

function M.editing()
  local opts = {remap = false, silent = true}

  km.nmap("J", "mzJ`z", opts)

  km.nmap(km.leader "O", "O<ESC>", opts)
  km.nmap(km.leader "o", "o<ESC>", opts)

  km.vmap("<", "<gv", opts)
  km.vmap(">", ">gv", opts)
end

function M.flutter()
  local companion = require("darcula.flutter")
  local opts = {remap = false, silent = true}

  if NV_DARCULA_ENABLE_COC then
    local coc_command = function(command)
      vim.cmd("CocCommand " .. command)
    end

    km.nmap(
      km.leader "fld",
      function()
        companion.flutter_list(false)
      end,
      opts
    )

    km.nmap(
      km.leader "flv",
      function()
        companion.flutter_list(false)
      end,
      opts
    )

    km.nmap(
      km.leader "fle",
      function()
        companion.flutter_list(true)
      end,
      opts
    )

    km.nmap(
      km.leader "flm",
      function()
        companion.flutter_run(true)
      end,
      opts
    )

    km.nmap(
      km.leader "flx",
      function()
        companion.flutter_run(false)
      end,
      opts
    )

    km.nmap(
      km.leader "flc",
      function()
        coc_command("flutter.dev.clearDevLog")
      end,
      opts
    )

    km.nmap(
      km.leader "flg",
      function()
        coc_command("flutter.pub.get")
      end,
      opts
    )
    km.nmap(
      km.leader "fll",
      function()
        coc_command("flutter.dev.openDevLog")
      end,
      opts
    )

    km.nmap(
      km.leader "flo",
      function()
        coc_command("flutter.toggleOutline")
      end,
      opts
    )

    km.nmap(
      km.leader "flp",
      function()
        coc_command("flutter.dev.openDevToolsProfiler")
      end,
      opts
    )

    km.nmap(
      km.leader "flq",
      function()
        coc_command("flutter.dev.quit")
      end,
      opts
    )

    km.nmap(
      km.leader "flr",
      function()
        coc_command("flutter.dev.hotReload")
      end,
      opts
    )

    km.nmap(
      km.leader "fls",
      function()
        coc_command("flutter.dev.hotRestart")
      end,
      opts
    )
  else
    km.nmap(
      km.leader "flc",
      function()
        vim.cmd("Telescope flutter commands")
      end,
      opts
    )
    km.nmap(
      km.leader "fld",
      function()
        companion.flutter_list(false)
      end,
      opts
    )
    km.nmap(
      km.leader "fle",
      function()
        companion.flutter_list(true)
      end,
      opts
    )
    km.nmap(
      km.leader "flm",
      function()
        companion.flutter_run(true)
      end,
      opts
    )
    km.nmap(
      km.leader "flv",
      function()
        companion.flutter_list(false)
      end,
      opts
    )
    km.nmap(
      km.leader "flx",
      function()
        companion.flutter_run(false)
      end,
      opts
    )
  end
end

function M.gitsigns(bufnr)
  local opts = {remap = false, silent = true, buffer = bufnr}

  km.nmap(
    km.leader2 "tb",
    function()
      NV_DARCULA_ENABLE_GIT_LINE_BLAME = not NV_DARCULA_ENABLE_GIT_LINE_BLAME
      require("gitsigns").toggle_current_line_blame(
        NV_DARCULA_ENABLE_GIT_LINE_BLAME
      )
      utils.notify_setting_enabled(
        "Git line blame",
        NV_DARCULA_ENABLE_GIT_LINE_BLAME
      )
    end,
    opts
  )

  km.nmap(
    km.leader "bl",
    function()
      vim.cmd("Gitsigns blame_line")
    end,
    opts
  )
end

function M.gui()
  if utils_ui.is_gui() then
    km.cmap("<c-s-v>", "<c-r>+", {remap = true})
    km.cmap("<c-v>", "<c-r>+", {remap = true})
    km.imap("<c-s-v>", "<c-r>+", {remap = true})
    km.imap("<c-v>", "<c-r>+", {remap = true})
    km.map("<c-s-v>", "p", {remap = true})
    km.map("<c-v>", "p", {remap = true})

    local opts = {remap = true, silent = true}
    km.nmap(
      km.leader2 "gd",
      function()
        NV_Darcula_Set_Gui_Font(0)
      end,
      opts
    )

    km.nmap(
      km.leader2 "gl",
      function()
        NV_Darcula_Set_Gui_Font(3)
      end,
      opts
    )

    km.nmap(
      km.leader2 "gm",
      function()
        NV_Darcula_Set_Gui_Font(2)
      end,
      opts
    )

    km.nmap(
      km.leader2 "gs",
      function()
        NV_Darcula_Set_Gui_Font(1)
      end,
      opts
    )
  end
end

if not NV_DARCULA_ENABLE_COC then
  function M.lsp()
    local opts = {remap = false, silent = true}

    km.nmap(km.leader "dl", vim.diagnostic.setloclist, opts)
    km.nmap(km.leader "dw", telescope_builtin.diagnostics, opts)
    km.nmap(km.leader "fs", telescope_builtin.lsp_document_symbols, opts)
    km.nmap(km.leader "fw", telescope_builtin.lsp_workspace_symbols, opts)
    km.nmap(
      km.leader "gn",
      function()
        vim.diagnostic.jump({count = 1, float = true})
      end,
      opts
    )
    km.nmap(
      km.leader "gp",
      function()
        vim.diagnostic.jump({count = -1, float = true})
      end,
      opts
    )

    km.nmap(
      km.leader "di",
      function()
        telescope_builtin.diagnostics({bufnr = 0})
      end,
      opts
    )

    km.nmap(
      km.leader "df",
      function()
        vim.diagnostic.open_float(nil, {focus = false})
      end,
      opts
    )

    km.map(
      km.leader "ii",
      function()
        vim.cmd("LspInfo")
      end,
      opts
    )

    km.set(
      {"i", "n"},
      "<C-s>",
      function()
        vim.lsp.buf.signature_help({border = "rounded"})
      end
    )
  end
end

if not NV_DARCULA_ENABLE_COC then
  function M.lsp_on_attach(ev)
    local client = vim.lsp.get_client_by_id(ev.data.client_id)
    if not client then
      return
    end

    local opts = {remap = false, silent = true, buffer = ev.buf}

    km.nmap(km.leader "aw", vim.lsp.buf.code_action, opts)
    km.nmap(km.leader "ca", vim.lsp.buf.code_action, opts)
    km.nmap(km.leader "gD", vim.lsp.buf.declaration, opts)
    km.nmap(km.leader "gd", telescope_builtin.lsp_definitions, opts)
    km.nmap(km.leader "gi", telescope_builtin.lsp_implementations, opts)
    km.nmap(km.leader "gr", telescope_builtin.lsp_references, opts)
    km.nmap(km.leader "gy", telescope_builtin.lsp_type_definitions, opts)
    km.nmap(km.leader "rn", vim.lsp.buf.rename, opts)

    km.vmap(
      km.leader "ac",
      function()
        vim.lsp.buf.range_code_action(nil, nil, nil)
      end,
      opts
    )

    km.vmap(
      km.leader "aw",
      function()
        vim.lsp.buf.range_code_action(nil, nil, nil)
      end,
      opts
    )

    km.vmap(
      km.leader "ca",
      function()
        vim.lsp.buf.range_code_action(nil, nil, nil)
      end,
      opts
    )
  end
end

if not NV_DARCULA_ENABLE_COC then
  function M.mason()
    km.map(km.leader "in", ":Mason<CR>", {remap = true, silent = true})
  end
end

function M.mini()
  if not NV_DARCULA_ENABLE_COC then
    local map_multistep = require("mini.keymap").map_multistep

    map_multistep(
      "i",
      "<Tab>",
      {
        "minisnippets_next",
        "minisnippets_expand",
        "pmenu_next"
      }
    )

    map_multistep(
      "i",
      "<S-Tab>",
      {
        "minisnippets_prev",
        "pmenu_prev"
      }
    )

    map_multistep(
      "i",
      "<CR>",
      {
        "pmenu_accept",
        "minipairs_cr"
      }
    )

    map_multistep(
      "i",
      "<BS>",
      {
        "minipairs_bs"
      }
    )
  end
end

function M.navigation()
  km.nmap(
    "<M-Left>",
    '"<Cmd>vertical resize -" . v:count1 . "<CR>"',
    {expr = true, replace_keycodes = false}
  )
  km.nmap(
    "<M-Down>",
    '"<Cmd>resize -"          . v:count1 . "<CR>"',
    {expr = true, replace_keycodes = false}
  )
  km.nmap(
    "<M-Up>",
    '"<Cmd>resize +"          . v:count1 . "<CR>"',
    {expr = true, replace_keycodes = false}
  )
  km.nmap(
    "<M-Right>",
    '"<Cmd>vertical resize +" . v:count1 . "<CR>"',
    {expr = true, replace_keycodes = false}
  )

  km.cmap("<C-h>", "<Left>", {silent = false})
  km.cmap("<C-l>", "<Right>", {silent = false})

  km.imap("<C-h>", "<Left>", {remap = true})
  km.imap("<C-l>", "<Right>", {remap = true})

  km.tmap("<C-h>", "<Left>")
  km.tmap("<C-l>", "<Right>")

  km.map(km.leader "0", "<C-i>", {remap = false})
  km.map(km.leader "8", "<C-^>", {remap = false})
  km.map(km.leader "9", "<C-o>", {remap = false})
  km.map(km.leader "h", "<C-W>h", {remap = true, silent = true})
  km.map(km.leader "j", "<C-W>j", {remap = true, silent = true})
  km.map(km.leader "k", "<C-W>k", {remap = true, silent = true})
  km.map(km.leader "l", "<C-W>l", {remap = true, silent = true})

  km.map(km.leader "mh", "<C-W>H", {remap = false})
  km.map(km.leader "mj", "<C-W>J", {remap = false})
  km.map(km.leader "mk", "<C-W>K", {remap = false})
  km.map(km.leader "ml", "<C-W>L", {remap = false})

  km.nmap("<s-n>", "Nzz", {remap = false})
  km.nmap("n", "nzz", {remap = false})

  km.nmap("j", "gj")
  km.nmap("k", "gk")
end

function M.nvim_dap()
  local dap = require("dap")
  km.nmap("<f5>", dap.continue, {remap = true, silent = true})
  km.nmap("<f8>", dap.toggle_breakpoint, {remap = true, silent = true})
  km.nmap("<f10>", dap.step_over, {remap = true, silent = true})
  km.nmap("<f11>", dap.step_into, {remap = true, silent = true})
  km.nmap("<f12>", dap.step_out, {remap = true, silent = true})
  km.set(
    {"n", "v", "x"},
    km.leader "vi",
    function()
      require("dapui").eval()
      require("dapui").eval()
    end,
    {remap = true, silent = true}
  )
end

function M.nvim_haven()
  km.nmap(
    km.leader "fy",
    require("darcula.haven").history,
    {remap = true, silent = true}
  )

  km.nmap(
    km.leader "ch",
    require("darcula.haven").clean,
    {remap = true, silent = true}
  )
end

function M.nvim_tree()
  local opts = {remap = false, silent = true}

  km.map(
    km.leader "ns",
    function()
      NV_Darcula_Open_Nvim_Tree(true)
    end,
    opts
  )

  km.map(
    km.leader "nt",
    function()
      NV_Darcula_Open_Nvim_Tree(false)
    end,
    opts
  )
end

function M.nvim_tree_on_attach(bufnr)
  local api = require("nvim-tree.api")

  local opts = function(desc)
    return {
      desc = "nvim-tree: " .. desc,
      buffer = bufnr,
      noremap = true,
      silent = true,
      nowait = true
    }
  end

  -- Default mappings. Feel free to modify or remove as you wish.
  --
  -- BEGIN_DEFAULT_ON_ATTACH
  vim.keymap.set("n", "<C-]>", api.tree.change_root_to_node, opts("CD"))
  vim.keymap.set(
    "n",
    "<C-e>",
    api.node.open.replace_tree_buffer,
    opts("Open: In Place")
  )
  vim.keymap.set("n", "<C-k>", api.node.show_info_popup, opts("Info"))
  vim.keymap.set("n", "<C-r>", api.fs.rename_sub, opts("Rename: Omit Filename"))
  vim.keymap.set("n", "<C-t>", api.node.open.tab, opts("Open: New Tab"))
  vim.keymap.set(
    "n",
    "<C-v>",
    api.node.open.vertical,
    opts("Open: Vertical Split")
  )
  vim.keymap.set(
    "n",
    "<C-x>",
    api.node.open.horizontal,
    opts("Open: Horizontal Split")
  )
  vim.keymap.set(
    "n",
    "<BS>",
    api.node.navigate.parent_close,
    opts("Close Directory")
  )
  vim.keymap.set("n", "<CR>", api.node.open.edit, opts("Open"))
  vim.keymap.set("n", "<Tab>", api.node.open.preview, opts("Open Preview"))
  vim.keymap.set("n", ">", api.node.navigate.sibling.next, opts("Next Sibling"))
  vim.keymap.set(
    "n",
    "<",
    api.node.navigate.sibling.prev,
    opts("Previous Sibling")
  )
  vim.keymap.set("n", ".", api.node.run.cmd, opts("Run Command"))
  vim.keymap.set("n", "-", api.tree.change_root_to_parent, opts("Up"))
  vim.keymap.set("n", "a", api.fs.create, opts("Create"))
  vim.keymap.set("n", "bmv", api.marks.bulk.move, opts("Move Bookmarked"))
  vim.keymap.set(
    "n",
    "B",
    api.tree.toggle_no_buffer_filter,
    opts("Toggle No Buffer")
  )
  vim.keymap.set("n", "c", api.fs.copy.node, opts("Copy"))
  vim.keymap.set(
    "n",
    "C",
    api.tree.toggle_git_clean_filter,
    opts("Toggle Git Clean")
  )
  vim.keymap.set("n", "[c", api.node.navigate.git.prev, opts("Prev Git"))
  vim.keymap.set("n", "]c", api.node.navigate.git.next, opts("Next Git"))
  vim.keymap.set("n", "d", api.fs.remove, opts("Delete"))
  vim.keymap.set("n", "D", api.fs.trash, opts("Trash"))
  vim.keymap.set("n", "E", api.tree.expand_all, opts("Expand All"))
  vim.keymap.set("n", "e", api.fs.rename_basename, opts("Rename: Basename"))
  vim.keymap.set(
    "n",
    "]e",
    api.node.navigate.diagnostics.next,
    opts("Next Diagnostic")
  )
  vim.keymap.set(
    "n",
    "[e",
    api.node.navigate.diagnostics.prev,
    opts("Prev Diagnostic")
  )
  vim.keymap.set("n", "F", api.live_filter.clear, opts("Clean Filter"))
  vim.keymap.set("n", "f", api.live_filter.start, opts("Filter"))
  vim.keymap.set("n", "g?", api.tree.toggle_help, opts("Help"))
  vim.keymap.set(
    "n",
    "gy",
    api.fs.copy.absolute_path,
    opts("Copy Absolute Path")
  )
  vim.keymap.set(
    "n",
    "H",
    api.tree.toggle_hidden_filter,
    opts("Toggle Dotfiles")
  )
  vim.keymap.set(
    "n",
    "I",
    api.tree.toggle_gitignore_filter,
    opts("Toggle Git Ignore")
  )
  vim.keymap.set("n", "J", api.node.navigate.sibling.last, opts("Last Sibling"))
  vim.keymap.set(
    "n",
    "K",
    api.node.navigate.sibling.first,
    opts("First Sibling")
  )
  vim.keymap.set("n", "m", api.marks.toggle, opts("Toggle Bookmark"))
  vim.keymap.set("n", "o", api.node.open.edit, opts("Open"))
  vim.keymap.set(
    "n",
    "O",
    api.node.open.no_window_picker,
    opts("Open: No Window Picker")
  )
  vim.keymap.set("n", "p", api.fs.paste, opts("Paste"))
  vim.keymap.set("n", "P", api.node.navigate.parent, opts("Parent Directory"))
  vim.keymap.set("n", "q", api.tree.close, opts("Close"))
  vim.keymap.set("n", "r", api.fs.rename, opts("Rename"))
  vim.keymap.set("n", "R", api.tree.reload, opts("Refresh"))
  -- vim.keymap.set("n", "s", api.node.run.system, opts("Run System"))
  vim.keymap.set("n", "S", api.tree.search_node, opts("Search"))
  vim.keymap.set("n", "U", api.tree.toggle_custom_filter, opts("Toggle Hidden"))
  vim.keymap.set("n", "W", api.tree.collapse_all, opts("Collapse"))
  vim.keymap.set("n", "x", api.fs.cut, opts("Cut"))
  vim.keymap.set("n", "y", api.fs.copy.filename, opts("Copy Name"))
  vim.keymap.set(
    "n",
    "Y",
    api.fs.copy.relative_path,
    opts("Copy Relative Path")
  )
  vim.keymap.set("n", "<2-LeftMouse>", api.node.open.edit, opts("Open"))
  vim.keymap.set(
    "n",
    "<2-RightMouse>",
    api.tree.change_root_to_node,
    opts("CD")
  )
  -- END_DEFAULT_ON_ATTACH

  -- Mappings migrated from view.mappings.list
  --
  -- You will need to insert "your code goes here" for any mappings with a custom action_cb
  vim.keymap.set("n", "-", api.tree.change_root_to_parent, opts("Up"))
  vim.keymap.set(
    "n",
    "<",
    api.node.navigate.sibling.prev,
    opts("Previous Sibling")
  )
  vim.keymap.set("n", "<CR>", api.node.open.edit, opts("Open"))
  vim.keymap.set("n", "o", api.node.open.edit, opts("Open"))
  vim.keymap.set("n", "<2-LeftMouse>", api.node.open.edit, opts("Open"))
  vim.keymap.set(
    "n",
    "<2-RightMouse>",
    api.tree.change_root_to_node,
    opts("CD")
  )
  vim.keymap.set("n", "CC", api.tree.change_root_to_node, opts("CD"))
  vim.keymap.set(
    "n",
    "<BS>",
    api.node.navigate.parent_close,
    opts("Close Directory")
  )
  vim.keymap.set("n", "<C-r>", api.fs.rename_sub, opts("Rename: Omit Filename"))
  vim.keymap.set("n", ">", api.node.navigate.sibling.next, opts("Next Sibling"))
  vim.keymap.set(
    "n",
    "I",
    api.tree.toggle_hidden_filter,
    opts("Toggle Dotfiles")
  )
  vim.keymap.set("n", "P", api.node.open.preview, opts("Open Preview"))
  vim.keymap.set(
    "n",
    "Y",
    api.fs.copy.relative_path,
    opts("Copy Relative Path")
  )
  vim.keymap.set("n", "a", api.fs.create, opts("Create"))
  vim.keymap.set("n", "c", api.fs.copy.node, opts("Copy"))
  vim.keymap.set(
    "n",
    "gy",
    api.fs.copy.absolute_path,
    opts("Copy Absolute Path")
  )
  vim.keymap.set(
    "n",
    "i",
    api.node.open.horizontal,
    opts("Open: Horizontal Split")
  )
  vim.keymap.set("n", "d", api.fs.remove, opts("Delete"))
  vim.keymap.set("n", "r", api.fs.rename, opts("Rename"))
  vim.keymap.set("n", "p", api.fs.paste, opts("Paste"))
  vim.keymap.set("n", "q", api.tree.close, opts("Close"))
  vim.keymap.set("n", "R", api.tree.reload, opts("Refresh"))
  vim.keymap.set("n", "s", api.node.open.vertical, opts("Open: Vertical Split"))
  vim.keymap.set("n", "x", api.fs.cut, opts("Cut"))
  vim.keymap.set("n", "y", api.fs.copy.filename, opts("Copy Name"))
  vim.keymap.set("n", "<C-t>", api.node.open.tab, opts("Open: New Tab"))
  vim.keymap.set("n", "f", api.node.navigate.parent, opts("Parent Directory"))
  vim.keymap.set(
    "n",
    "K",
    api.node.navigate.sibling.first,
    opts("First Sibling")
  )
  vim.keymap.set("n", "J", api.node.navigate.sibling.last, opts("Last Sibling"))
  vim.keymap.set("n", "[c", api.node.navigate.git.prev, opts("Prev Git"))
  vim.keymap.set("n", "]c", api.node.navigate.git.next, opts("Next Git"))
  vim.keymap.set("n", "?", api.tree.toggle_help, opts("Help"))
end

function M.nvim_window_picker()
  local opts = {remap = true, silent = true}
  km.map(km.leader "sw", ":WindowPick<cr>", opts)
  km.map(km.leader "sW", ":WindowSwap<cr>", opts)
end

function M.quickfix()
  local opts = {remap = false, silent = true}

  km.nmap(km.leader "co", NV_Darcula_Copen, opts)
  km.nmap(km.leader "qc", ":cclose<CR>", opts)
  km.nmap(km.leader "qn", ":cn<CR>", opts)
  km.nmap(km.leader "qo", ":copen<CR>", opts)
  km.nmap(km.leader "qp", ":cp<CR>", opts)

  km.nmap(km.leader2 "lc", ":lclose<CR>", opts)
  km.nmap(km.leader2 "ln", ":lnext<CR>", opts)
  km.nmap(km.leader2 "lo", ":lopen<CR>", opts)
  km.nmap(km.leader2 "lp", ":lprevious<CR>", opts)
end

function M.starter()
  km.nmap(
    km.leader "st",
    function()
      if vim.fn.bufname("%"):starts_with("NvimTree") then
        vim.cmd("wincmd l")
      end

      vim.cmd("NvimTreeClose")
      MiniStarter.open()
    end,
    {remap = false, silent = true}
  )
end

function M.tab()
  local opts = {remap = false, silent = true}

  km.nmap(km.leader2 "bb", ":tabnext #<cr>", opts)
  km.nmap(km.leader2 "bc", ":tabnew<cr>", opts)
  km.nmap(km.leader2 "bf", ":tabfirst<cr>", opts)
  km.nmap(km.leader2 "bl", ":tablast<cr>", opts)
  km.nmap(km.leader2 "bn", ":tabnext<cr>", opts)
  km.nmap(km.leader2 "bp", ":tabprevious<cr>", opts)
  km.nmap(km.leader2 "bq", ":tabclose<cr>", opts)
  km.nmap(km.leader2 "bs", ":tab split<cr>", opts)
end

function M.telescope()
  local opts = {remap = false, silent = true}

  km.nmap(km.leader "es", telescope_builtin.grep_string, opts)
  km.vmap(
    km.leader "es",
    function()
      NV_Darcula_Grab_Selection(
        function(word)
          telescope_builtin.grep_string({search = word})
        end
      )
    end,
    opts
  )

  km.nmap(km.leader "fb", telescope_builtin.buffers, opts)
  km.nmap(km.leader "fc", telescope_builtin.colorscheme, opts)
  km.nmap(km.leader "fg", telescope_builtin.git_files, opts)
  km.nmap(km.leader "fh", telescope_builtin.help_tags, opts)
  km.nmap(km.leader "fi", telescope_builtin.command_history, opts)
  km.nmap(km.leader "fm", telescope_builtin.man_pages, opts)
  km.nmap(km.leader "fp", telescope_builtin.keymaps, opts)
  km.nmap(km.leader "ft", telescope_builtin.git_status, opts)
  km.nmap(km.leader "fz", telescope_builtin.current_buffer_fuzzy_find, opts)
  km.nmap(km.leader "rg", telescope_builtin.live_grep, opts)

  km.nmap(
    km.leader "ff",
    function()
      telescope_builtin.find_files({hidden = true})
    end,
    opts
  )
end

function M.toggle()
  local opts = {remap = false, silent = true}

  -- Fixed height
  km.nmap(
    km.leader2 "fh",
    function()
      vim.cmd("setlocal winfixheight!")
      utils.notify_setting_enabled("Fixed height", vim.opt.winfixheight:get())
    end,
    opts
  )

  -- Fixed width
  km.nmap(
    km.leader2 "fw",
    function()
      vim.cmd("setlocal winfixwidth!")
      utils.notify_setting_enabled("Fixed width", vim.opt.winfixwidth:get())
    end,
    opts
  )

  -- Colorizer
  km.nmap(
    km.leader2 "tc",
    function()
      vim.cmd("ColorizerToggle")
    end,
    opts
  )

  -- Document Formatting
  km.nmap(
    km.leader2 "tf",
    function()
      NV_DARCULA_ENABLE_FORMATTING = not NV_DARCULA_ENABLE_FORMATTING
      utils.notify_setting_enabled(
        "Text formatting",
        NV_DARCULA_ENABLE_FORMATTING
      )
    end,
    opts
  )

  km.nmap(
    km.leader2 "tF",
    function()
      utils.notify_setting_enabled(
        "Text formatting",
        NV_DARCULA_ENABLE_FORMATTING
      )
    end,
    opts
  )

  -- List mode
  km.map(
    km.leader2 "tl",
    function()
      vim.cmd("set list!")
      utils.notify_setting_enabled("List mode", vim.opt.list:get())
    end,
    opts
  )

  km.map(
    km.leader2 "tL",
    function()
      utils.notify_setting_enabled("List mode", vim.opt.list:get())
    end,
    opts
  )

  -- Relative line numbers
  km.nmap(
    km.leader2 "tr",
    function()
      vim.cmd("set invrelativenumber")
      utils.notify_setting_enabled(
        "Relative numbers",
        vim.opt.relativenumber:get()
      )
    end,
    opts
  )

  km.nmap(
    km.leader2 "tR",
    function()
      utils.notify_setting_enabled(
        "Relative numbers",
        vim.opt.relativenumber:get()
      )
    end,
    opts
  )

  -- Line wrapping
  km.nmap(
    km.leader2 "tw",
    function()
      vim.cmd("set invwrap")
      utils.notify_setting_enabled("Line wrapping", vim.opt.wrap:get())
    end,
    opts
  )

  km.nmap(
    km.leader2 "tW",
    function()
      utils.notify_setting_enabled("Line wrapping", vim.opt.wrap:get())
    end,
    opts
  )
end

function M.treesitter()
  local swap = require("nvim-treesitter-textobjects.swap")

  km.nmap(
    "<leader>mar",
    function()
      swap.swap_next "@parameter.inner"
    end
  )

  km.nmap(
    "<leader>mal",
    function()
      swap.swap_previous "@parameter.inner"
    end
  )
end

function M.vim()
  local opts = {remap = false, silent = true}

  km.tmap("<C-b>", "<C-\\><C-n>", opts)

  km.map(km.leader "wa", NV_Darcula_Write_All, opts)
  km.nmap("K", NV_Darcula_Show_Documentation, opts)
  km.nmap(km.leader "=", "<C-w>=", opts)
  km.nmap(
    km.leader "bq",
    function()
      local buffer_name = vim.fn.bufname()
      if buffer_name ~= nil then
        if buffer_name:starts_with("NvimTree") then
          vim.cmd("wincmd l")
        end

        for _, value in pairs(vim.api.nvim_list_bufs()) do
          if value ~= vim.fn.bufnr() then
            buffer_name = vim.fn.bufname(value)
            if
              buffer_name ~= nil and not buffer_name:starts_with("NvimTree") and
                not buffer_name:starts_with("term:")
             then
              vim.cmd("silent! bd! " .. value)
            end
          end
        end
      end
    end,
    opts
  )
  km.nmap(km.leader2 "m", ":Messages<CR>", opts)
  km.nmap(
    km.leader2 "n",
    function()
      vim.cmd("vert new")
      vim.opt_local.wrap = true
      MiniNotify.show_history()
    end,
    opts
  )
  km.nmap(km.leader "cf", ":echo expand('%:p')<CR>", opts)
  km.nmap(km.leader "ci", NV_Darcula_Close_Invalid, opts)
  km.nmap(km.leader "cn", ":echo expand('%:t')<CR>", opts)
  km.nmap(km.leader "cp", ":echo expand('%:p')<CR>", opts)
  km.nmap(km.leader "cr", ":echo @%<CR>", opts)
  km.nmap(km.leader "ee", NV_Darcula_Refresh_Buffer, opts)
  km.nmap(km.leader "nh", ":noh<cr>", opts)
  km.nmap(km.leader "nm", "]m", opts)
  km.nmap(km.leader "pm", "[m", opts)
  km.nmap(
    km.leader "sla",
    ":%s/\\ /\\r/g<cr>:noh<cr>",
    {remap = true, silent = true}
  )
  km.nmap(
    km.leader "sll",
    ":s/\\ /\\r/g<cr>:noh<cr>",
    {remap = true, silent = true}
  )
  km.nmap(km.leader "sp", ":sp<cr>", opts)
  km.nmap(km.leader "te", ":term<cr>", opts)
  km.nmap(km.leader "v", "<C-v>", opts)
  km.nmap(km.leader "vs", ":vs<cr>", opts)
  km.vmap("p", '"_dP', opts)
  km.vmap(km.leader "ss", ":sort<cr>", opts)

  km.set(
    {"n", "v"},
    km.leader "dd",
    NV_Darcula_Show_Documentation,
    {remap = true, silent = true}
  )
  km.set(
    {"n", "v"},
    km.leader "dh",
    NV_Darcula_Show_Documentation,
    {remap = true, silent = true}
  )

  km.nmap(
    km.leader "dm",
    function()
      NV_Darcula_Show_Man_Documentation(false)
    end,
    opts
  )

  km.vmap(
    km.leader "dm",
    function()
      NV_Darcula_Show_Man_Documentation(true)
    end,
    opts
  )

  km.map(
    km.leader "qa",
    function()
      NV_Darcula_Close_All(false)
    end,
    opts
  )

  km.map(
    km.leader "qq",
    function()
      if vim.bo.buftype == "prompt" then
        vim.api.nvim_input("<esc>")
        return
      end
      vim.cmd("q")
    end,
    opts
  )

  km.map(
    km.leader "wqa",
    function()
      NV_Darcula_Close_All(true)
    end,
    opts
  )

  km.map(
    km.leader "ww",
    function()
      if vim.bo.buftype ~= "prompt" then
        vim.cmd("w")
      end
    end,
    opts
  )

  km.nmap(
    km.leader "dv",
    function()
      NV_Darcula_Show_Vim_Documentation(false)
    end,
    opts
  )

  km.vmap(
    km.leader "dv",
    function()
      NV_Darcula_Show_Vim_Documentation(true)
    end,
    opts
  )
end

function M.vim_fugitive()
  local opts = {remap = false, silent = true}

  km.nmap(km.leader "tc", ":Git commit<cr>", opts)
  km.nmap(km.leader "tp", ":Git push<cr>", opts)
  km.nmap(km.leader "ts", ":Git<cr>", opts)
  km.nmap(km.leader "tu", ":Git pull<cr>", opts)
  km.nmap(km.leader "tl", ":Telescope git_commits<cr>", opts)
  km.nmap(km.leader "ttl", ":Git reflog<cr>", opts)
  km.nmap(km.leader "ttL", ":GcLog<cr>", opts)
end

(function()
  if NV_DARCULA_ENABLE_COC then
    M.coc()
  end
  M.commenting()
  M.cppman()
  M.cspell()
  M.diff()
  M.editing()
  M.flutter()
  M.gui()
  if not NV_DARCULA_ENABLE_COC then
    M.lsp()
  end
  if not NV_DARCULA_ENABLE_COC then
    M.mason()
  end
  M.mini()
  M.navigation()
  M.nvim_dap()
  M.nvim_haven()
  M.nvim_tree()
  M.nvim_window_picker()
  M.quickfix()
  M.starter()
  M.tab()
  M.telescope()
  M.toggle()
  M.treesitter()
  M.vim()
  M.vim_fugitive()
end)()

return M