-- coding.lua - 代码增强插件配置

return {
  -- LSP 配置
  {
    "neovim/nvim-lspconfig",
    event = { "BufReadPre", "BufNewFile" },
    dependencies = {
      -- LSP 管理器
      { "williamboman/mason.nvim" },
      { "williamboman/mason-lspconfig.nvim" },
      
      -- 自动安装 LSP
      { "WhoIsSethDaniel/mason-tool-installer.nvim" },
      
      -- 显示 LSP 进度
      { "j-hui/fidget.nvim", opts = {} },
      
      -- 额外 LSP 功能
      { "folke/neodev.nvim", opts = {} },
    },
    opts = {
      -- LSP 服务器诊断设置
      diagnostics = {
        underline = true,
        update_in_insert = false,
        virtual_text = {
          spacing = 4,
          source = "if_many",
          prefix = "●",
        },
        severity_sort = true,
        signs = {
          text = {
            [vim.diagnostic.severity.ERROR] = "✘",
            [vim.diagnostic.severity.WARN] = "▲",
            [vim.diagnostic.severity.HINT] = "⚑",
            [vim.diagnostic.severity.INFO] = "»",
          },
        },
      },
      
      -- 自动格式化
      format = {
        formatting_options = nil,
        timeout_ms = 1000,
      },
      
      -- LSP 服务器设置
      servers = {
        -- 根据语言配置服务器
        lua_ls = {
          settings = {
            Lua = {
              completion = {
                callSnippet = "Replace",
              },
              workspace = {
                checkThirdParty = false,
              },
              telemetry = {
                enable = false,
              },
              diagnostics = {
                globals = { "vim" },
              },
            },
          },
        },

        -- Python 服务器
        pyright = {
          settings = {
            python = {
              analysis = {
                typeCheckingMode = "basic",
                autoSearchPaths = true,
                useLibraryCodeForTypes = true,
                diagnosticMode = "workspace",
              },
            },
          },
        },
        ruff_lsp = {
          -- Ruff 会处理导入和排序
          init_options = {
            settings = {
              args = {},
            },
          },
        },

        -- Go 服务器
        gopls = {
          settings = {
            gopls = {
              gofumpt = true,
              codelenses = {
                gc_details = true,
                generate = true,
                regenerate_cgo = true,
                run_govulncheck = true,
                test = true,
                tidy = true,
                upgrade_dependency = true,
                vendor = true,
              },
              hints = {
                assignVariableTypes = true,
                compositeLiteralFields = true,
                compositeLiteralTypes = true,
                constantValues = true,
                functionTypeParameters = true,
                parameterNames = true,
                rangeVariableTypes = true,
              },
              analyses = {
                fieldalignment = true,
                nilness = true,
                unusedparams = true,
                unusedwrite = true,
                useany = true,
                shadow = true,
              },
              usePlaceholders = true,
              completeUnimported = true,
              staticcheck = true,
              directoryFilters = { "-.git", "-.vscode", "-.idea", "-.vscode-test", "-node_modules" },
              semanticTokens = true,
            },
          },
        },
      },
    },
    config = function(_, opts)
      -- 设置诊断标志
      for name, icon in pairs(opts.diagnostics.signs.text) do
        name = "DiagnosticSign" .. name
        vim.fn.sign_define(name, { text = icon, texthl = name, numhl = "" })
      end
      
      -- 配置诊断
      vim.diagnostic.config(vim.deepcopy(opts.diagnostics))
      
      -- 设置 LSP 的键绑定和自动命令
      vim.api.nvim_create_autocmd("LspAttach", {
        callback = function(args)
          local buffer = args.buf
          local client = vim.lsp.get_client_by_id(args.data.client_id)
          
          -- 设置 LSP 键绑定
          local map = function(mode, l, r, opts_)
            opts_ = opts_ or {}
            opts_.silent = true
            opts_.buffer = buffer
            vim.keymap.set(mode, l, r, opts_)
          end
          
          -- 导航键绑定
          map("n", "gd", "<cmd>Telescope lsp_definitions<cr>", { desc = "转到定义" })
          map("n", "gr", "<cmd>Telescope lsp_references<cr>", { desc = "查找引用" })
          map("n", "gD", vim.lsp.buf.declaration, { desc = "转到声明" })
          map("n", "gI", "<cmd>Telescope lsp_implementations<cr>", { desc = "转到实现" })
          map("n", "gt", "<cmd>Telescope lsp_type_definitions<cr>", { desc = "转到类型定义" })
          map("n", "K", vim.lsp.buf.hover, { desc = "显示悬停信息" })
          map("n", "gK", vim.lsp.buf.signature_help, { desc = "显示签名帮助" })
          
          -- 代码操作键绑定
          map("n", "<leader>ca", vim.lsp.buf.code_action, { desc = "代码操作" })
          map("n", "<leader>cr", vim.lsp.buf.rename, { desc = "重命名" })
          
          -- 诊断键绑定
          map("n", "]d", vim.diagnostic.goto_next, { desc = "下一个诊断" })
          map("n", "[d", vim.diagnostic.goto_prev, { desc = "上一个诊断" })
          map("n", "<leader>cd", vim.diagnostic.open_float, { desc = "行诊断" })
          map("n", "<leader>cl", "<cmd>LspInfo<cr>", { desc = "LSP 信息" })
          
          -- 格式化文档（如果服务器支持）
          if client and client.supports_method("textDocument/formatting") then
            map("n", "<leader>cf", vim.lsp.buf.format, { desc = "格式化代码" })
          end
        end,
      })
      
      -- 设置 LSP 服务器
      local capabilities = vim.tbl_deep_extend(
        "force",
        {},
        vim.lsp.protocol.make_client_capabilities(),
        require("cmp_nvim_lsp").default_capabilities(),
        opts.capabilities or {}
      )
      
      -- 为 Lua 开发环境配置
      require("neodev").setup({
        library = {
          plugins = { "nvim-dap-ui" },
          types = true,
        },
      })
      
      -- 设置 mason-lspconfig
      require("mason").setup()
      
      local ensure_installed = {} -- 要安装的服务器列表
      
      -- 收集需要安装的服务器
      for server, server_opts in pairs(opts.servers) do
        if server_opts then
          server_opts = server_opts == true and {} or server_opts
          -- 将服务器添加到安装列表
          ensure_installed[#ensure_installed + 1] = server
        end
      end
      
      -- 设置 mason-lspconfig
      require("mason-lspconfig").setup({
        ensure_installed = vim.tbl_keys(ensure_installed),
        automatic_installation = true,
      })
      
      -- 设置工具安装程序
      require("mason-tool-installer").setup({
        ensure_installed = {
          -- Python 工具
          "black",
          "isort",
          "mypy",
          "ruff",
          "debugpy",
          
          -- Go 工具
          "gofumpt",
          "goimports",
          "golangci-lint",
          "delve",
          
          -- 通用工具
          "stylua",
          "shfmt",
        },
      })
      
      -- 启动服务器
      require("mason-lspconfig").setup_handlers({
        function(server)
          local server_opts = vim.tbl_deep_extend("force", {
            capabilities = vim.deepcopy(capabilities),
          }, opts.servers[server] or {})

          -- 特殊设置钩子
          if server == "ruff_lsp" then
            -- 使用 LspAttach 自动命令来配置 ruff_lsp
            vim.api.nvim_create_autocmd("LspAttach", {
              callback = function(args)
                local client = vim.lsp.get_client_by_id(args.data.client_id)
                -- 禁用 ruff 格式化功能，由 conform 处理
                if client and client.name == "ruff_lsp" then
                  client.server_capabilities.documentFormattingProvider = false
                end
              end,
            })
          end

          -- 启动服务器
          require("lspconfig")[server].setup(server_opts)
        end,
      })
    end,
  },
  
  -- 自动完成
  {
    "hrsh7th/nvim-cmp",
    version = false,
    event = "InsertEnter",
    dependencies = {
      "hrsh7th/cmp-nvim-lsp",
      "hrsh7th/cmp-buffer",
      "hrsh7th/cmp-path",
      "saadparwaiz1/cmp_luasnip",
      "hrsh7th/cmp-cmdline",
    },
    opts = function()
      vim.api.nvim_set_hl(0, "CmpGhostText", { link = "Comment", default = true })
      local cmp = require("cmp")
      local luasnip = require("luasnip")
      
      local function has_words_before()
        unpack = unpack or table.unpack
        local line, col = unpack(vim.api.nvim_win_get_cursor(0))
        return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
      end
      
      return {
        completion = {
          completeopt = "menu,menuone,noinsert",
        },
        snippet = {
          expand = function(args)
            luasnip.lsp_expand(args.body)
          end,
        },
        mapping = cmp.mapping.preset.insert({
          ["<C-n>"] = cmp.mapping.select_next_item({ behavior = cmp.SelectBehavior.Insert }),
          ["<C-p>"] = cmp.mapping.select_prev_item({ behavior = cmp.SelectBehavior.Insert }),
          ["<C-b>"] = cmp.mapping.scroll_docs(-4),
          ["<C-f>"] = cmp.mapping.scroll_docs(4),
          ["<C-Space>"] = cmp.mapping.complete(),
          ["<C-e>"] = cmp.mapping.abort(),
          ["<CR>"] = cmp.mapping.confirm({ select = true }),
          ["<S-CR>"] = cmp.mapping.confirm({
            behavior = cmp.ConfirmBehavior.Replace,
            select = true,
          }),
          ["<Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
              cmp.select_next_item()
            elseif luasnip.expand_or_jumpable() then
              luasnip.expand_or_jump()
            elseif has_words_before() then
              cmp.complete()
            else
              fallback()
            end
          end, { "i", "s" }),
          ["<S-Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
              cmp.select_prev_item()
            elseif luasnip.jumpable(-1) then
              luasnip.jump(-1)
            else
              fallback()
            end
          end, { "i", "s" }),
        }),
        sources = cmp.config.sources({
          { name = "nvim_lsp", priority = 1000 },
          { name = "luasnip", priority = 750 },
          { name = "buffer", priority = 500 },
          { name = "path", priority = 250 },
        }),
        formatting = {
          format = function(entry, vim_item)
            -- 添加源信息
            vim_item.menu = ({
              nvim_lsp = "[LSP]",
              luasnip = "[Snip]",
              buffer = "[Buf]",
              path = "[Path]",
            })[entry.source.name]
            
            -- 设置最大宽度
            local MAX_LABEL_WIDTH = 50
            if #vim_item.abbr > MAX_LABEL_WIDTH then
              vim_item.abbr = vim_item.abbr:sub(1, MAX_LABEL_WIDTH) .. "..."
            end
            
            return vim_item
          end,
        },
        experimental = {
          ghost_text = {
            hl_group = "CmpGhostText",
          },
        },
      }
    end,
    config = function(_, opts)
      -- 设置 nvim-cmp
      local cmp = require("cmp")
      cmp.setup(opts)
      
      -- 为命令行设置完成
      cmp.setup.cmdline(":", {
        mapping = cmp.mapping.preset.cmdline(),
        sources = cmp.config.sources({
          { name = "path" },
          { name = "cmdline" },
        }),
      })
      
      -- 为搜索设置完成
      cmp.setup.cmdline("/", {
        mapping = cmp.mapping.preset.cmdline(),
        sources = cmp.config.sources({
          { name = "buffer" },
        }),
      })
    end,
  },
  
  -- 代码格式化和 Linting
  {
    "stevearc/conform.nvim",
    event = { "BufReadPre", "BufNewFile" },
    cmd = { "ConformInfo" },
    keys = {
      {
        "<leader>cf",
        function()
          require("conform").format({ lsp_fallback = true, async = false })
        end,
        mode = { "n", "v" },
        desc = "格式化代码",
      },
    },
    opts = {
      formatters_by_ft = {
        lua = { "stylua" },
        python = { "isort", "black" },
        go = { "goimports", "gofumpt" },
        javascript = { "prettierd" },
        typescript = { "prettierd" },
        javascriptreact = { "prettierd" },
        typescriptreact = { "prettierd" },
        json = { "prettierd" },
        html = { "prettierd" },
        css = { "prettierd" },
        yaml = { "prettierd" },
        markdown = { "prettierd" },
        sh = { "shfmt" },
      },
      
      -- 每个格式化工具的设置
      formatters = {
        black = {
          args = { "--line-length", "88", "--fast", "-" },
        },
        isort = {
          args = { "--stdout", "--profile", "black", "--line-length", "88", "-" },
        },
        stylua = {
          args = { "--indent-type", "Spaces", "--indent-width", "2", "-" },
        },
      },
      
      -- 保存时自动格式化
      format_on_save = function(bufnr)
        if vim.b[bufnr].disable_autoformat or vim.g.disable_autoformat then
          return
        end
        return { timeout_ms = 500, lsp_fallback = true }
      end,
      
      -- 格式化超时时间
      format_after_save = function(bufnr)
        if vim.b[bufnr].disable_autoformat or vim.g.disable_autoformat then
          return
        end
        return { lsp_fallback = true }
      end,
    },
    init = function()
      -- 添加用户命令以切换格式化
      vim.api.nvim_create_user_command("FormatToggle", function(args)
        if args.bang then
          -- FormatToggle! 将为当前缓冲区切换格式化
          vim.b.disable_autoformat = not vim.b.disable_autoformat
          vim.notify(string.format("Buffer autoformatting %s", vim.b.disable_autoformat and "disabled" or "enabled"))
        else
          -- FormatToggle 将全局切换格式化
          vim.g.disable_autoformat = not vim.g.disable_autoformat
          vim.notify(string.format("Global autoformatting %s", vim.g.disable_autoformat and "disabled" or "enabled"))
        end
      end, { desc = "切换自动格式化", bang = true })
    end,
  },
  
  -- 调试支持
  {
    "mfussenegger/nvim-dap",
    dependencies = {
      -- UI 相关
      {
        "rcarriga/nvim-dap-ui",
        dependencies = { "nvim-neotest/nvim-nio" },
        keys = {
          { "<leader>du", function() require("dapui").toggle() end, desc = "Dap UI" },
        },
        opts = {},
        config = function(_, opts)
          local dap = require("dap")
          local dapui = require("dapui")
          dapui.setup(opts)
          dap.listeners.after.event_initialized["dapui_config"] = function()
            dapui.open()
          end
          dap.listeners.before.event_terminated["dapui_config"] = function()
            dapui.close()
          end
          dap.listeners.before.event_exited["dapui_config"] = function()
            dapui.close()
          end
        end,
      },
      -- 虚拟文本支持
      {
        "theHamsta/nvim-dap-virtual-text",
        opts = {},
      },
      -- Python 调试支持
      {
        "mfussenegger/nvim-dap-python",
        config = function()
          local path = require("mason-registry").get_package("debugpy"):get_install_path()
          require("dap-python").setup(path .. "/venv/bin/python")
        end,
      },
      -- Go 调试支持
      {
        "leoluz/nvim-dap-go",
        config = true,
      },
    },
    keys = {
      { "<leader>dB", function() require("dap").set_breakpoint(vim.fn.input('断点条件: ')) end, desc = "条件断点" },
      { "<leader>db", function() require("dap").toggle_breakpoint() end, desc = "切换断点" },
      { "<leader>dc", function() require("dap").continue() end, desc = "继续执行" },
      { "<leader>da", function() require("dap").continue({ before = get_args }) end, desc = "带参数运行" },
      { "<leader>dC", function() require("dap").run_to_cursor() end, desc = "运行到光标处" },
      { "<leader>dg", function() require("dap").goto_() end, desc = "跳转到行" },
      { "<leader>di", function() require("dap").step_into() end, desc = "单步进入" },
      { "<leader>dj", function() require("dap").down() end, desc = "下栈帧" },
      { "<leader>dk", function() require("dap").up() end, desc = "上栈帧" },
      { "<leader>dl", function() require("dap").run_last() end, desc = "运行最后的配置" },
      { "<leader>do", function() require("dap").step_out() end, desc = "单步跳出" },
      { "<leader>dO", function() require("dap").step_over() end, desc = "单步跳过" },
      { "<leader>dp", function() require("dap").pause() end, desc = "暂停执行" },
      { "<leader>dr", function() require("dap").repl.toggle() end, desc = "切换 REPL" },
      { "<leader>ds", function() require("dap").session() end, desc = "获取会话" },
      { "<leader>dt", function() require("dap").terminate() end, desc = "终止调试" },
      { "<leader>dw", function() require("dap.ui.widgets").hover() end, desc = "小部件" },
    },
    config = function()
      local icons = {
        dap = {
          Stopped = { "󰁕 ", "DiagnosticWarn", "DapStoppedLine" },
          Breakpoint = " ",
          BreakpointCondition = " ",
          BreakpointRejected = { " ", "DiagnosticError" },
          LogPoint = ".>",
        },
      }
      
      vim.api.nvim_set_hl(0, "DapStoppedLine", { default = true, link = "Visual" })
      
      for name, sign in pairs(icons.dap) do
        sign = type(sign) == "table" and sign or { sign }
        vim.fn.sign_define(
          "Dap" .. name,
          { text = sign[1], texthl = sign[2] or "DiagnosticInfo", linehl = sign[3], numhl = sign[3] }
        )
      end
    end,
  },
  
  -- 问题检测器
  {
    "folke/trouble.nvim",
    cmd = { "TroubleToggle", "Trouble" },
    opts = {
      use_diagnostic_signs = true,
      action_keys = {
        close = "q",
        cancel = "<esc>",
        refresh = "r",
        jump = { "<cr>", "<tab>", "<2-leftmouse>" },
        open_split = { "<c-s>" },
        open_vsplit = { "<c-v>" },
        open_tab = { "<c-t>" },
        jump_close = { "o" },
        toggle_mode = "m",
        switch_severity = "s",
        toggle_preview = "P",
        hover = "K",
        preview = "p",
        close_folds = { "zM", "zm" },
        open_folds = { "zR", "zr" },
        toggle_fold = { "zA", "za" },
        previous = "k",
        next = "j",
        help = "?",
      },
    },
    keys = {
      { "<leader>xx", "<cmd>TroubleToggle document_diagnostics<cr>", desc = "文档诊断" },
      { "<leader>xX", "<cmd>TroubleToggle workspace_diagnostics<cr>", desc = "工作区诊断" },
      { "<leader>xL", "<cmd>TroubleToggle loclist<cr>", desc = "位置列表" },
      { "<leader>xQ", "<cmd>TroubleToggle quickfix<cr>", desc = "快速修复" },
      {
        "[q",
        function()
          if require("trouble").is_open() then
            require("trouble").previous({ skip_groups = true, jump = true })
          else
            local ok, err = pcall(vim.cmd.cprev)
            if not ok then
              vim.notify(err, vim.log.levels.ERROR)
            end
          end
        end,
        desc = "上一个问题",
      },
      {
        "]q",
        function()
          if require("trouble").is_open() then
            require("trouble").next({ skip_groups = true, jump = true })
          else
            local ok, err = pcall(vim.cmd.cnext)
            if not ok then
              vim.notify(err, vim.log.levels.ERROR)
            end
          end
        end,
        desc = "下一个问题",
      },
    },
  },
}