vim.o.shell = "/bin/sh"

vim.g.loaded_node_provider = false
vim.g.loaded_perl_provider = false
vim.g.loaded_python_provider = false
vim.g.loaded_ruby_provider = false

vim.o.number = true
vim.o.hidden = true

vim.o.expandtab = true
vim.o.tabstop = 4
vim.o.softtabstop = 4
vim.o.shiftwidth = 4
vim.o.smartindent = true
vim.o.foldenable = false
vim.o.joinspaces = false
vim.o.nrformats = vim.o.nrformats .. ",blank"

-- Some ftplugin files will add 'o' back in again, so remove it again after the
-- filetype has been determined.
vim.opt.formatoptions = "crqnlj"
vim.cmd([[ autocmd Filetype * setlocal formatoptions-=o ]])

vim.o.wrap = true
vim.o.linebreak = true
vim.keymap.set("", "j", "gj", { silent = true })
vim.keymap.set("", "k", "gk", { silent = true })

vim.o.list = false
vim.o.wrapmargin = 0
vim.opt.listchars = {
  tab = ">-",
  extends = ">",
  precedes = "<",
  nbsp = "+",
  trail = "-",
}

vim.o.ignorecase = true
vim.o.smartcase = true

vim.o.cursorline = true

vim.o.splitbelow = true
vim.o.splitright = true

vim.o.modelines = 0
vim.o.lazyredraw = true
vim.o.updatetime = 250

vim.opt.shortmess:append("I")

vim.opt.wildignore:append("*.swp,*~")

vim.opt.completeopt = "menu,menuone,noselect"

vim.o.secure = true

vim.api.nvim_create_autocmd("FileType", {
  pattern = { "markdown", "text" },
  callback = function()
    vim.opt_local.spell = true
  end,
})
vim.opt.spellcapcheck = ""

vim.diagnostic.config({
  jump = {
    on_jump = function(diagnostic, bufnr)
      if not diagnostic then
        return
      end

      vim.diagnostic.show(diagnostic.namespace, bufnr, { diagnostic }, { float = true })
    end,
  },
})

vim.keymap.set("", "<Space>w", "<C-w>", { remap = true })

vim.keymap.set("", ";", ":nohlsearch<cr>")
vim.keymap.set("", ",", ":nohlsearch<cr>")

-------------------------------------------------------------------------------
-- Theme
-------------------------------------------------------------------------------

vim.pack.add({ "https://github.com/rktjmp/lush.nvim" })

theme = "jdkaplan-temp"
vim.cmd.colorscheme(theme)

-- CTRL-L usually clears and redraws the screen.  Might as well use it to reset
-- the colorscheme too!
vim.keymap.set("n", "<C-l>", function()
  vim.cmd.colorscheme(theme)
  vim.cmd.redraw()
end)

-------------------------------------------------------------------------------
-- tpope extended universe
-------------------------------------------------------------------------------

vim.pack.add({
  "https://github.com/tpope/vim-abolish",
  "https://github.com/tpope/vim-commentary",
  "https://github.com/tpope/vim-repeat",
  "https://github.com/tpope/vim-fugitive",
})

vim.pack.add({ "https://github.com/kylechui/nvim-surround" })
require("nvim-surround").setup()

-------------------------------------------------------------------------------
-- Editing
-------------------------------------------------------------------------------

vim.pack.add({ "https://github.com/windwp/nvim-autopairs" })
require("nvim-autopairs").setup({
  opts = {
    map_cr = true,
    enable_moveright = true,
    enable_check_bracket_line = false,
    check_ts = true,
  },
})

-------------------------------------------------------------------------------
-- IDE
-------------------------------------------------------------------------------

vim.pack.add({ "https://github.com/preservim/nerdtree" })
vim.keymap.set("n", "<Space>tt", ":NERDTreeToggle<cr>")
vim.keymap.set("n", "<Space>tf", ":NERDTreeFind<cr>")

vim.pack.add({ "https://github.com/lewis6991/gitsigns.nvim" })
require("gitsigns").setup({
  signcolumn = false,
  current_line_blame = false,
  current_line_blame_formatter = "  <author> <author_time:%Y-%m-%d> <summary>",
  current_line_blame_opts = {
    virt_text = true,
    virt_text_pos = "eol",
    delay = 0,
    ignore_whitespace = false,
  },
});
(function()
  local gitsigns = require("gitsigns")
  local toggle = function(value)
    -- BUG: (?) If the blame delay is not zero, the setting can
    -- enter a race with cursor movement and leave a ghost blame in
    -- the buffer.

    show = not show
    gitsigns.toggle_current_line_blame(show)
    gitsigns.toggle_deleted(show)
    gitsigns.toggle_signs(show)
  end

  vim.keymap.set("n", "<leader>gg", toggle)
  vim.keymap.set("n", "[h", gitsigns.prev_hunk)
  vim.keymap.set("n", "]h", gitsigns.next_hunk)
end)()

-------------------------------------------------------------------------------
-- Treesitter
-------------------------------------------------------------------------------

vim.pack.add({
  {
    src = "https://github.com/nvim-treesitter/nvim-treesitter",
    version = "4916d6592ede8c07973490d9322f187e07dfefac",
  },
  "https://github.com/nvim-treesitter/nvim-treesitter-textobjects",
})
vim.api.nvim_create_autocmd("PackChanged", {
  callback = function(ev)
    local name, kind = ev.data.spec.name, ev.data.kind
    if name == "nvim-treesitter" and (kind == "install" or kind == "update") then
      require("nvim-treesitter").update()
    end
  end,
})
require("nvim-treesitter").install({
  "bash",
  "css",
  "dot",
  "diff",
  "git_config",
  "git_rebase",
  "gitattributes",
  "gitcommit",
  "gitignore",
  "go",
  "gomod",
  "gosum",
  "gowork",
  "html",
  "javascript",
  "jq",
  "json",
  "lua",
  "markdown",
  "markdown_inline",
  "proto",
  "python",
  "ruby",
  "rust",
  "scss",
  "sql",
  "toml",
  "tsx",
  "typescript",
  "yaml",
})
require("nvim-treesitter-textobjects").setup({
  enable = true,
  select = {
    enable = true,
    lookahead = true,
    include_surrounding_whitespace = false,
    -- https://github.com/nvim-treesitter/nvim-treesitter-textobjects#overriding-or-extending-textobjects
    keymaps = {
      ["af"] = "@function.outer",
      ["if"] = "@function.inner",
      ["ac"] = "@comment.outer",
      ["ic"] = "@comment.outer",
    },
  },
  move = {
    enable = true,
    set_jumps = true,
    goto_next_start = {
      ["]m"] = "@function.outer",
      ["]{"] = "@block.outer",
    },
    goto_next_end = {
      ["]M"] = "@function.outer",
      ["]}"] = "@block.outer",
    },
    goto_previous_start = {
      ["[m"] = "@function.outer",
      ["[{"] = "@block.outer",
    },
    goto_previous_end = {
      ["[M"] = "@function.outer",
      ["[}"] = "@block.outer",
    },
  },
})

vim.pack.add({ "https://github.com/lukas-reineke/indent-blankline.nvim" })
require("ibl").setup({
  indent = {
    char = "┊",
  },
  scope = { enabled = false },
})

vim.pack.add({ "https://github.com/stevearc/aerial.nvim" })
require("aerial").setup()
vim.keymap.set("n", "<Space>st", "<cmd>AerialNavToggle<cr>")

-------------------------------------------------------------------------------
-- Telescope
-------------------------------------------------------------------------------

vim.pack.add({
  {
    src = "https://github.com/nvim-telescope/telescope.nvim",
    version = vim.version.range("^0.2"),
  },
  "https://github.com/nvim-lua/plenary.nvim",
  "https://github.com/nvim-telescope/telescope-fzf-native.nvim",
  "https://github.com/nvim-telescope/telescope-ui-select.nvim",
})
-- TODO: Is it possible to make this run synchronously here, but only on install/update?
vim
  .system({ "make" }, {
    cwd = vim.pack.get({ "telescope-fzf-native.nvim" })[1].path,
  })
  :wait();
(function()
  local telescope = require("telescope")
  telescope.load_extension("fzf")
  telescope.load_extension("aerial")
  telescope.load_extension("ui-select")

  local builtin = require("telescope.builtin")

  local function find_files(opts)
    opts = opts or {}
    opts["hidden"] = true
    return builtin.find_files(opts)
  end

  vim.keymap.set("n", "<Space>f", find_files)
  vim.keymap.set("n", "<Space>/", builtin.live_grep)
  vim.keymap.set("n", "<Space>b", builtin.buffers)
  vim.keymap.set("n", "<Space>*", builtin.grep_string)
  vim.keymap.set("n", "<Space>o", telescope.extensions.aerial.aerial)

  vim.keymap.set("n", "<Space><Space>", builtin.builtin)
  vim.keymap.set("i", "<Space>i", builtin.symbols)

  local actions = require("telescope.actions")
  local action_state = require("telescope.actions.state")
  local transform_mod = require("telescope.actions.mt").transform_mod

  -- https://github.com/nvim-telescope/telescope.nvim/issues/1048#issuecomment-1225975038
  local function multiopen(prompt_bufnr, method)
    local method = method or "default"

    local edit_file_cmd_map = {
      vertical = "vsplit",
      horizontal = "split",
      tab = "tabedit",
      default = "edit",
    }
    local edit_buf_cmd_map = {
      vertical = "vert sbuffer",
      horizontal = "sbuffer",
      tab = "tab sbuffer",
      default = "buffer",
    }

    local picker = action_state.get_current_picker(prompt_bufnr)
    local multi_selection = picker:get_multi_selection()

    if #multi_selection > 1 then
      require("telescope.pickers").on_close_prompt(prompt_bufnr)
      pcall(vim.api.nvim_set_current_win, picker.original_win_id)

      for i, entry in ipairs(multi_selection) do
        local filename, row, col

        if entry.path or entry.filename then
          filename = entry.path or entry.filename

          row = entry.row or entry.lnum
          col = vim.F.if_nil(entry.col, 1)
        elseif not entry.bufnr then
          local value = entry.value
          if not value then
            goto continue
          end

          if type(value) == "table" then
            value = entry.display
          end

          local sections = vim.split(value, ":")

          filename = sections[1]
          row = tonumber(sections[2])
          col = tonumber(sections[3])
        end

        local entry_bufnr = entry.bufnr

        if entry_bufnr then
          if not vim.api.nvim_buf_get_option(entry_bufnr, "buflisted") then
            vim.api.nvim_buf_set_option(entry_bufnr, "buflisted", true)
          end
          local command = i == 1 and "buffer" or edit_buf_cmd_map[method]
          pcall(vim.cmd, string.format("%s %s", command, vim.api.nvim_buf_get_name(entry_bufnr)))
        else
          local command = i == 1 and "edit" or edit_file_cmd_map[method]
          if vim.api.nvim_buf_get_name(0) ~= filename or command ~= "edit" then
            filename = require("plenary.path"):new(vim.fn.fnameescape(filename)):normalize(vim.loop.cwd())
            pcall(vim.cmd, string.format("%s %s", command, filename))
          end
        end

        if row and col then
          pcall(vim.api.nvim_win_set_cursor, 0, { row, col - 1 })
        end

        ::continue::
      end
    else
      actions["select_" .. method](prompt_bufnr)
    end
  end

  telescope.setup({
    defaults = {
      mappings = {
        i = {
          ["<CR>"] = multiopen,
        },
        n = {
          ["<CR>"] = multiopen,
        },
      },
      vimgrep_arguments = {
        "rg",
        "--color=never",
        "--no-heading",
        "--with-filename",
        "--line-number",
        "--column",
        "--smart-case",
        -- Include hidden files, but continue ignoring the .git directory itself.
        "--hidden",
        "--iglob",
        "!.git",
      },
    },
    pickers = {},
    extensions = {
      aerial = {},
    },
  })
end)()

-------------------------------------------------------------------------------
-- Completion and snippets
-------------------------------------------------------------------------------

vim.pack.add({
  {
    src = "https://github.com/L3MON4D3/LuaSnip",
    version = vim.version.range("^2"),
  },
  "https://github.com/hrsh7th/cmp-nvim-lsp",
  "https://github.com/hrsh7th/nvim-cmp",
  "https://github.com/saadparwaiz1/cmp_luasnip",
})

-- TODO: Is it possible to make this run synchronously here, but only on install/update?
vim
  .system({ "make", "install_jsregexp" }, {
    cwd = vim.pack.get({ "LuaSnip" })[1].path,
  })
  :wait();
(function()
  local luasnip = require("luasnip")

  luasnip.filetype_extend("typescript", { "javascript" })
  luasnip.filetype_extend("typescriptreact", { "javascript", "react" })

  -- Put snippets in ./snippets/<filetype>.snippets
  require("luasnip.loaders.from_snipmate").lazy_load()
  require("luasnip.loaders.from_lua").lazy_load()

  local cmp = require("cmp")
  cmp.setup({
    completion = {
      autocomplete = false,
    },
    snippet = {
      expand = function(args)
        luasnip.lsp_expand(args.body)
      end,
    },
    mapping = cmp.mapping.preset.insert({
      ["<C-f>"] = cmp.mapping.scroll_docs(4),
      ["<C-b>"] = cmp.mapping.scroll_docs(-4),
      ["<C-Space>"] = cmp.mapping.complete(),
      ["<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()
        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 = {
      { name = "nvim_lsp" },
      { name = "luasnip" },
    },
  })
end)()

-------------------------------------------------------------------------------
-- Language-specific plugins
-------------------------------------------------------------------------------

-- Rust
vim.pack.add({ {
  src = "https://github.com/mrcjkb/rustaceanvim",
  version = vim.version.range("^9"),
} })

-- Uiua
vim.pack.add({ "https://github.com/Apeiros-46B/uiua.vim" })

-------------------------------------------------------------------------------
-- Language Server Protocol (LSP)
-------------------------------------------------------------------------------

vim.pack.add({ "https://github.com/neovim/nvim-lspconfig" })

vim.lsp.inlay_hint.enable(true)

vim.api.nvim_create_autocmd("LspAttach", {
  callback = function(args)
    local client = assert(vim.lsp.get_client_by_id(args.data.client_id))

    if client:supports_method("textDocument/completion") then
      vim.lsp.completion.enable(true, client.id, args.buf, { autotrigger = false })
    end

    -- Usually not needed if server supports "textDocument/willSaveWaitUntil".
    already_waits = client:supports_method("textDocument/willSaveWaitUntil")
    can_fmt = client:supports_method("textDocument/formatting")

    should_fmt = ({
      -- tsserver/ts_ls seems to have no other way of disabling formatting.
      ["ts_ls"] = false,
      -- zls doesn't seem to trigger the normal way.
      ["zls"] = true,
    })[client.name]

    if should_fmt == nil then
      should_fmt = not already_waits and can_fmt
    end

    if should_fmt then
      vim.api.nvim_create_autocmd("BufWritePre", {
        buffer = args.buf,
        callback = function()
          vim.lsp.buf.format({ bufnr = args.buf, id = client.id, timeout_ms = 1000 })
        end,
      })
    end
  end,
})

vim.lsp.enable("eslint")
vim.lsp.config("eslint", {
  on_attach = function(client, bufnr)
    vim.api.nvim_create_autocmd("BufWritePre", {
      callback = function()
        client:request_sync("workspace/executeCommand", {
          command = "eslint.applyAllFixes",
          arguments = {
            {
              uri = vim.uri_from_bufnr(bufnr),
              version = vim.lsp.util.buf_versions[bufnr],
            },
          },
        })
      end,
    })
  end,
})

vim.lsp.enable("stylua")

-- rust-analyzer is already enabled and configured by rustaceanvim

vim.lsp.enable("uiua")

vim.lsp.enable("zls")
vim.lsp.config("zls", {
  settings = {
    enable_build_on_save = true,
    inlay_hints_hide_redundant_param_names = true,
    inlay_hints_hide_redundant_param_names_last_token = true,
    warn_style = true,
  },
})

-------------------------------------------------------------------------------
-- which-key
-------------------------------------------------------------------------------

vim.pack.add({ "https://github.com/folke/which-key.nvim" })
require("which-key").setup({
  preset = "helix",
  keys = {
    Up = " ",
    Down = " ",
    Left = " ",
    Right = " ",
    C = "^",
    M = "M-",
    D = "W-",
    S = "S-",
    CR = "CR",
    Esc = "Esc",
    ScrollWheelDown = "⤓",
    ScrollWheelUp = "⤒",
    NL = "⏎",
    BS = "⇐",
    Space = "Space",
    Tab = "Tab",
    F1 = "F1",
    F2 = "F2",
    F3 = "F3",
    F4 = "F4",
    F5 = "F5",
    F6 = "F6",
    F7 = "F7",
    F8 = "F8",
    F9 = "F9",
    F10 = "F10",
    F11 = "F11",
    F12 = "F12",
  },
})

vim.keymap.set("", "<Space>?", function()
  require("which-key").show()
end, { desc = "which-key" })