mappings.lua

-- add yours here

local map = vim.keymap.set
local command = vim.api.nvim_create_user_command
local Snacks = require("snacks")
local tools = require("kide.tools")

--- 退出可视模式, 让后续能安全操作 buffer
local function exit_visual()
  vim.api.nvim_feedkeys("\027", "xt", false)
end

--- 可视模式映射用: 退出可视模式后取整个选区
---@return string[]
local function visual_selection()
  exit_visual()
  return tools.get_visual_selection()
end

--- 命令回调取可视选区, 无 range 时返回 nil
---@param opt table
---@return string[]?
local function visual_lines(opt)
  if opt.range > 0 then
    return tools.get_visual_selection()
  end
end

--- 命令回调取文本: 有 range 时用可视选区, 否则用命令行参数
---@param opt table
---@return string
local function text_of(opt)
  if opt.range > 0 then
    return table.concat(tools.get_visual_selection(), "\n")
  end
  return opt.args or ""
end

local function codex_edit_selection(opt)
  local code
  local line_info = nil
  if opt.range > 0 then
    code = tools.get_visual_selection()
    line_info = opt.line1 == opt.line2 and tostring(opt.line1) or (opt.line1 .. "-" .. opt.line2)
  else
    local line = vim.api.nvim_win_get_cursor(0)[1]
    code = vim.api.nvim_buf_get_lines(0, line - 1, line, false)
    line_info = tostring(line)
  end
  if not code or vim.tbl_isempty(code) then
    vim.notify("请先选择要交给 Code 修改的代码", vim.log.levels.WARN)
    return
  end
  local prompt = opt.args
  if not prompt or prompt == "" then
    prompt = vim.fn.input("Code edit: ")
  end

  local filetype = vim.bo.filetype
  local filename = require("kide.code_agent").buffer_path(0)

  local message = {}
  if prompt and prompt ~= "" then
    table.insert(message, prompt)
  end
  if filename ~= "" then
    table.insert(message, "文件: " .. filename .. (line_info and (":" .. line_info) or ""))
  end
  table.insert(message, "```" .. (filetype ~= "" and filetype or ""))
  table.insert(message, table.concat(code, "\n"))
  table.insert(message, "```")

  require("kide.code_agent").send(table.concat(message, "\n"))
end

map("n", "<A-i>", function()
  require("kide.term").toggle()
  -- 只有真正显示终端时才进入终端插入模式, 关闭/隐藏时不要误进 insert
  if vim.bo.buftype == "terminal" then
    vim.cmd("startinsert")
  end
end, { desc = "toggle term" })
map("t", "<A-i>", require("kide.term").toggle, { desc = "toggle term" })
map("i", "<A-i>", function()
  vim.cmd("stopinsert")
  require("kide.term").toggle()
end, { desc = "toggle term" })
map("v", "<A-i>", function()
  local text = visual_selection()
  require("kide.term").open()
  vim.defer_fn(function()
    require("kide.term").send_line(text[1])
  end, 500)
end, { desc = "send selection to term" })

map("n", "<leader>gb", function()
  require("gitsigns").blame_line()
end, { desc = "gitsigns blame line" })
map("n", "<ESC>", "<CMD>noh<CR>", { desc = "Clear Highlight" })

map("n", "<up>", "<CMD>res +5<CR>", { desc = "Resize +5" })
map("n", "<down>", "<CMD>res -5<CR>", { desc = "Resize -5" })
map("n", "<S-up>", "<CMD>res -5<CR>", { desc = "Resize -5" })
map("n", "<S-down>", "<CMD>res +5<CR>", { desc = "Resize +5" })
map("n", "<left>", "<CMD>vertical resize+5<CR>", { desc = "Vertical Resize +5" })
map("n", "<right>", "<CMD>vertical resize-5<CR>", { desc = "Vertical Resize -5" })
map("n", "<S-left>", "<CMD>vertical resize-5<CR>", { desc = "Vertical Resize -5" })
map("n", "<S-right>", "<CMD>vertical resize+5<CR>", { desc = "Vertical Resize +5" })

vim.keymap.set({ "t", "i" }, "<A-h>", "<C-\\><C-n><C-w>h")
vim.keymap.set({ "t", "i" }, "<A-j>", "<C-\\><C-n><C-w>j")
vim.keymap.set({ "t", "i" }, "<A-k>", "<C-\\><C-n><C-w>k")
vim.keymap.set({ "t", "i" }, "<A-l>", "<C-\\><C-n><C-w>l")
vim.keymap.set({ "n" }, "<A-h>", "<C-w>h")
vim.keymap.set({ "n" }, "<A-j>", "<C-w>j")
vim.keymap.set({ "n" }, "<A-k>", "<C-w>k")
vim.keymap.set({ "n" }, "<A-l>", "<C-w>l")
-- terminal
map("t", "<C-x>", "<C-\\><C-N>", { desc = "terminal escape terminal mode" })

-- dap
map("n", "<F5>", function()
  require("dap").continue()
end, {
  desc = "Dap continue",
})
map("n", "<F10>", function()
  require("dap").step_over()
end, {
  desc = "Dap step_over",
})
map("n", "<F11>", function()
  require("dap").step_into()
end, {
  desc = "Dap step_into",
})
map("n", "<F12>", function()
  require("dap").step_out()
end, {
  desc = "Dap step_out",
})
map("n", "<leader>db", function()
  require("dap").toggle_breakpoint()
end, { desc = "Dap toggle breakpoint" })
map("n", "<leader>dB", function()
  require("dap").set_breakpoint(vim.fn.input("Breakpoint condition: "))
end, { desc = "Dap breakpoint condition" })
map("n", "<leader>dl", function()
  require("dap").run_last()
end, {
  desc = "Dap run last",
})
map("n", "<Leader>lp", function()
  require("dap").set_breakpoint(nil, nil, vim.fn.input("Log point message: "))
end, {
  desc = "Dap set_breakpoint",
})
map("n", "<Leader>dr", function()
  require("dap").repl.open()
end, {
  desc = "Dap repl open",
})
map({ "n", "v" }, "<Leader>dh", function()
  require("dap.ui.widgets").hover()
end, {
  desc = "Dap hover",
})
map({ "n", "v" }, "<Leader>dp", function()
  require("dap.ui.widgets").preview()
end, {
  desc = "Dap preview",
})
map("n", "<Leader>df", function()
  local widgets = require("dap.ui.widgets")
  widgets.centered_float(widgets.frames)
end, {
  desc = "Dap centered_float frames",
})
map("n", "<Leader>dv", function()
  local widgets = require("dap.ui.widgets")
  widgets.centered_float(widgets.scopes)
end, {
  desc = "Dap centered_float scopes",
})

map("n", "<leader>e", function()
  Snacks.explorer.open({})
  -- require('oil').open_float()
end, { desc = "files", silent = true, noremap = true })

-- outline
map("n", "<leader>o", "<CMD>Outline<CR>", { desc = "Symbols Outline" })

-- task
command("Run", function(opt)
  local term = require("kide.term")
  if opt.args ~= "" then
    term.last_input = opt.args
    term.toggle(opt.args)
    return
  end
  if term.last_input and term.last_input ~= "" then
    term.toggle(term.last_input)
    return
  end
  vim.notify("No command to run", vim.log.levels.WARN)
end, {
  desc = "Run Task",
  nargs = "*",
  complete = function(arglead, cmdline, cursorpos)
    return require("kide.term").complete(arglead, cmdline, cursorpos, { prefix = "Run" })
  end,
})

map({ "n", "v" }, "<C-l>", function()
  vim.lsp.buf.format({
    async = false,
  })
end, { desc = "format file" })

-- Git
map("n", "]c", function()
  local gs = require("gitsigns")
  if vim.wo.diff then
    return "]c"
  end
  vim.schedule(function()
    gs.next_hunk()
  end)
  return "<Ignore>"
end, { expr = true, desc = "Git Next Hunk" })

map("n", "[c", function()
  local gs = require("gitsigns")
  if vim.wo.diff then
    return "[c"
  end
  vim.schedule(function()
    gs.prev_hunk()
  end)
  return "<Ignore>"
end, { expr = true, desc = "Git Prev Hunk" })

map("n", "[e", function()
  vim.diagnostic.jump({ count = -1, severity = vim.diagnostic.severity.ERROR, float = true })
end, { desc = "Jump to the previous diagnostic error" })
map("n", "]e", function()
  vim.diagnostic.jump({ count = 1, severity = vim.diagnostic.severity.ERROR, float = true })
end, { desc = "Jump to the next diagnostic error" })
map("n", "go", vim.diagnostic.open_float, { desc = "Open float Diagnostics" })

-- quickfix next/prev
-- map("n", "]q", "<CMD>cnext<CR>", { desc = "Quickfix Next" })
-- map("n", "[q", "<CMD>cprev<CR>", { desc = "Quickfix Prev" })

-- local list next/prev
-- map("n", "]l", "<CMD>lnext<CR>", { desc = "Location List Next" })
-- map("n", "[l", "<CMD>lprev<CR>", { desc = "Location List Prev" })

command("InlayHint", function()
  vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({}))
end, { desc = "LSP Inlay Hint" })
command("CodeLens", function()
  vim.lsp.codelens.enable(not vim.lsp.codelens.is_enabled({}))
end, { desc = "LSP CodeLens" })

command("LspDocumentSymbols", function(_)
  vim.lsp.buf.document_symbol()
end, {
  desc = "Lsp Document Symbols",
  nargs = 0,
  range = true,
})

command("LspWorkspaceSymbols", function(opts)
  local text = visual_lines(opts)
  if text then
    vim.lsp.buf.workspace_symbol(text[1])
  else
    vim.lsp.buf.workspace_symbol(opts.args)
  end
end, {
  desc = "Lsp Workspace Symbols",
  nargs = "?",
  range = true,
})

local severity_key = {
  "ERROR",
  "WARN",
  "INFO",
  "HINT",
}
command("DiagnosticsWorkspace", function(opts)
  local level = opts.args
  if level == nil or level == "" then
    vim.diagnostic.setqflist()
  else
    vim.diagnostic.setqflist({ severity = vim.diagnostic.severity[string.upper(level)] })
  end
end, {
  desc = "Diagnostics Workspace",
  nargs = "?",
  complete = function(al, _, _)
    return vim.tbl_filter(function(item)
      return vim.startswith(item, al)
    end, severity_key)
  end,
})
command("DiagnosticsDocument", function(opts)
  local level = opts.args
  if level == nil or level == "" then
    vim.diagnostic.setloclist()
  else
    vim.diagnostic.setloclist({ severity = vim.diagnostic.severity[string.upper(level)] })
  end
end, {
  desc = "Diagnostics Document",
  nargs = "?",
  complete = function(al, _, _)
    return vim.tbl_filter(function(item)
      return vim.startswith(item, al)
    end, severity_key)
  end,
})

-- find files
if vim.fn.executable("fd") == 1 then
  command("Fd", function(opt)
    vim.fn.setqflist(
      {},
      " ",
      { lines = vim.fn.systemlist("fd --type file " .. opt.args), efm = "%f" }
    )
    vim.cmd("botright copen")
  end, {
    desc = "find files",
    nargs = "?",
  })
end
if vim.fn.executable("find") == 1 then
  command("Find", function(opt)
    vim.fn.setqflist(
      {},
      " ",
      { lines = vim.fn.systemlist("find . -type f -iname '" .. opt.args .. "'"), efm = "%f" }
    )
    vim.cmd("botright copen")
  end, {
    desc = "find files",
    nargs = 1,
  })
end
command("CloseOtherBufs", function(_)
  local bufs = vim.api.nvim_list_bufs()
  local cur = vim.api.nvim_get_current_buf()
  for _, v in ipairs(bufs) do
    if vim.bo[v].buflisted and cur ~= v then
      local ok = pcall(vim.api.nvim_buf_delete, v, { force = false, unload = false })
      if not ok then
        vim.cmd("b " .. v)
        return
      end
    end
  end
end, {
  desc = "find files",
  nargs = 0,
})

map("n", "<leader>fq", function()
  require("kide.fzy").quickfix()
end, { desc = "Quickfix" })

map("n", "<leader>fb", function()
  require("kide.fzy").buffers()
end, { desc = "Find buffer" })
map("n", "<leader>ff", function()
  require("kide.fzy").files()
end, { desc = "Find files" })
map("n", "<leader>fo", function()
  require("kide.fzy").oldfiles()
end, { desc = "Find oldfiles" })

map("n", "<leader>fd", function()
  Snacks.picker.diagnostics()
end, { desc = "Find diagnostics" })

map("v", "<leader>ff", function()
  local text = visual_selection()
  require("kide.fzy").files({ query = text[1] })
end, { desc = "find files", silent = true, noremap = true })

map("v", "<leader>fw", function()
  local text = visual_selection()
  require("kide.rg").live_grep({ query = text[1] })
end, { desc = "live grep", silent = true, noremap = true })
map("n", "<leader>fw", function()
  require("kide.rg").live_grep()
end, { desc = "live grep", silent = true, noremap = true })

if vim.base64 then
  command("Base64Encode", function(opt)
    vim.notify(vim.base64.encode(text_of(opt)), vim.log.levels.INFO)
  end, {
    desc = "base64 encode",
    nargs = "?",
    range = true,
  })
  command("Base64Decode", function(opt)
    local text = tools.base64_url_safe_to_std(text_of(opt))
    vim.notify(vim.base64.decode(text), vim.log.levels.INFO)
  end, {
    desc = "base64 decode",
    nargs = "?",
    range = true,
  })
end

--- 注册一对翻译命令: `:Trans<name>` 弹浮窗, `:Trans<name>VT` 写虚拟文本
---@param name string 命令名中缀
---@param from string
---@param to string
local function creat_trans_commands(name, from, to)
  command("Trans" .. name, function(opt)
    require("kide.gpt.translate").translate_float({ text = text_of(opt), from = from, to = to })
  end, { desc = "translate", nargs = "?", range = true })

  command("Trans" .. name .. "VT", function(opt)
    local anchor_lnum = vim.api.nvim_win_get_cursor(0)[1]
    if opt.range > 0 then
      anchor_lnum = opt.line2
    end
    require("kide.gpt.translate").translate_virtual_text({
      text = text_of(opt),
      from = from,
      to = to,
      anchor_lnum = anchor_lnum,
    })
  end, { desc = "translate virtual text", nargs = "?", range = true })
end

for _, trans in ipairs({
  { "AutoZh", "auto", "中文" },
  { "EnZh", "英语", "中文" },
  { "ZhEn", "中文", "英语" },
  { "IdZh", "印尼语", "中文" },
}) do
  creat_trans_commands(trans[1], trans[2], trans[3])
end
command("TransClearVT", function(opt)
  local req = {}
  if opt.range > 0 then
    req.start_lnum = opt.line1
    req.end_lnum = opt.line2
  end
  require("kide.gpt.translate").clear_virtual_text(req)
end, {
  desc = "clear translate virtual text",
  range = true,
})

command("GptChat", function(opt)
  local q
  local code = visual_lines(opt)
  if opt.args and opt.args ~= "" then
    q = opt.args
  end
  require("kide.gpt.chat").toggle_gpt({
    code = code,
    question = q,
  })
end, {
  desc = "GptChat",
  nargs = "*",
  range = true,
})
command("GptLast", function()
  require("kide.gpt.chat").toggle_gpt({
    last = true,
  })
end, {
  desc = "Gpt",
  nargs = "*",
  range = true,
})

command("Gpt", function(opt)
  local args = opt.args
  local code = visual_lines(opt)
  if args and args ~= "" then
    if args == "linux" then
      require("kide.gpt.chat").toggle_gpt({
        gpt = require("kide.gpt.chat").linux,
        code = code,
      })
    elseif args == "lsp" then
      local cursor = vim.api.nvim_win_get_cursor(0)
      local diagnostics = vim.diagnostic.get(0, {
        lnum = cursor[1] - 1,
      })
      if #diagnostics > 0 then
        require("kide.gpt.chat").toggle_gpt({
          gpt = require("kide.gpt.chat").lsp,
          code = code,
          diagnostics = diagnostics,
        })
      else
        vim.notify("没有诊断信息", vim.log.levels.INFO)
      end
    else
      vim.notify("没有指定助手类型: " .. args, vim.log.levels.WARN)
    end
  else
    vim.notify("没有指定助手类型", vim.log.levels.WARN)
  end
end, {
  desc = "Gpt Assistant",
  nargs = 1,
  range = true,
  complete = function()
    return { "linux", "lsp" }
  end,
})

command("GptReasoner", function(opt)
  local q
  local code = visual_lines(opt)
  if opt.args and opt.args ~= "" then
    q = opt.args
  end
  require("kide.gpt.chat").toggle_gpt({
    gpt = require("kide.gpt.chat").reasoner,
    code = code,
    question = q,
  })
end, {
  desc = "Gpt",
  nargs = "*",
  range = true,
})

command("GptProvider", function(opt)
  if opt.args and opt.args ~= "" then
    require("kide.gpt.provide").select_provide(opt.args)
  else
    vim.ui.select(require("kide.gpt.provide").provide_keys(), {
      prompt = "Select GPT Provides:",
      format_item = function(item)
        return item
      end,
    }, function(c)
      require("kide.gpt.provide").select_provide(c)
    end)
  end
end, {
  desc = "GptProvider",
  nargs = "?",
  range = false,
  complete = function()
    return require("kide.gpt.provide").provide_keys()
  end,
})

command("GptModels", function(_)
  vim.ui.select(require("kide.gpt.provide").models(), {
    prompt = "Select GPT Models:",
    format_item = function(item)
      return item
    end,
  }, function(c)
    require("kide.gpt.provide").select_model(c)
  end)
end, {
  desc = "GptModels",
  nargs = 0,
  range = false,
})

command("LspInfo", function(_)
  require("kide.lspui").open_info()
end, {
  desc = "Lsp info",
  nargs = 0,
  range = false,
})

command("NotificationHistory", function(_)
  Snacks.notifier.show_history()
end, {
  desc = "Notification History",
  nargs = 0,
  range = false,
})

command("LspLog", function(_)
  vim.cmd("tabedit " .. vim.lsp.log.get_filename())
  vim.cmd("normal! G")
end, {
  desc = "Lsp log",
  nargs = 0,
  range = false,
})

command("Go", function(opt)
  local cmd = { "go" }
  if opt.args and opt.args ~= "" then
    vim.list_extend(cmd, vim.split(opt.args, " "))
  end
  require("kide.term").toggle(cmd)
end, {
  desc = "Go cmd",
  nargs = "*",
  range = false,
  complete = "file",
})
command("ImageHover", function()
  Snacks.image.hover()
end, {
  desc = "Image Hover",
  nargs = 0,
  range = false,
})

if vim.fn.executable("cargo-owlsp") == 1 then
  map("n", "<A-o>", require("kide.lsp.rustowl").rustowl_cursor, { noremap = true, silent = true })
end

command("CodeAgent", function()
  require("kide.code_agent").toggle()
end, {
  desc = "CodeAgent cmd",
  nargs = 0,
  range = false,
})

-- 每个 code agent 一个同名命令: :Codex / :OpenCode / :Claude / :Pi
for _, name in ipairs(require("kide.code_agent").agent_names) do
  command(name, function()
    require("kide.code_agent").select(name)
  end, { desc = name .. " cmd", nargs = 0, range = false })
end

command("CodeEdit", codex_edit_selection, {
  desc = "Send selected code to Code for editing",
  nargs = "*",
  range = true,
})

command("CodeFix", function(opt)
  local code = visual_lines(opt)
  require("kide.code_agent").fix_diagnostics({
    code = code,
    extra_prompt = opt.args,
  })
end, {
  desc = "Send diagnostics to Code for fixing",
  nargs = "*",
  range = true,
})

map({ "i", "n", "t" }, "<A-;>", function()
  require("kide.code_agent").toggle()
end, { desc = "Code Agent" })

map("v", "<leader>ce", function()
  exit_visual()
  codex_edit_selection({
    range = 1,
    args = "",
  })
end, { desc = "Code edit selection" })

map({ "n", "t" }, "<A-g>", function()
  require("kide.gitui").gitui()
end, { desc = "gitui" })

-- vim.keymap.set("i", "<C-k>", function()
--   vim.snippet.expand([[
-- function ${1:name}(${2:args}) {
--   ${0}
-- }
-- ]])
-- end)
-- 跳到下一个占位符
-- inoremap <expr> <cr> pumvisible() ? '<c-y>' : '<cr>'
vim.keymap.set({ "i", "s" }, "<Tab>", function()
  if vim.snippet.active({ direction = 1 }) then
    return "<Cmd>lua vim.snippet.jump(1)<CR>"
  end
  return "<Tab>"
end, { expr = true })

-- 跳回上一个
vim.keymap.set({ "i", "s" }, "<S-Tab>", function()
  if vim.snippet.active({ direction = -1 }) then
    return "<Cmd>lua vim.snippet.jump(-1)<CR>"
  end
  return "<S-Tab>"
end, { expr = true })

tools.setup()
require("kide.term").setup()
require("kide.tools.infer").setup()
require("kide.tools.plantuml").setup()
require("kide.tools.mermaid").setup()
require("kide.tools.curl").setup()
require("kide.gpt.commit").setup()
require("kide.gpt.code").setup()