local hostname = "@HOSTNAME@"

local servers = {
	textlab = {},
	lua_ls = {},
	rust_analyzer = {},
	nixd = {
		nixpkgs = {
			expr = 'import (builtins.getFlake "/etc/nixos").inputs.nixpkgs {}',
		},
		formatting = { command = { "nixfmt" } },
		options = {
			nixos = {
				expr = '(builtins.getFlake "/etc/nixos").nixosConfigurations.' .. hostname .. ".options",
			},
			home_manager = {
				expr = '(builtins.getFlake "/etc/nixos").homeConfigurations.' .. hostname .. ".options",
			},
		},
	},
	phpactor = {},
	zls = {
		settings = {
			zls = {
				enable_build_on_save = true,
				semantic_tokens = "partial",
			},
		},
	},
	css = {},
	scss = {},
	less = {},
	blade = {},
	html = { filetypes = { "html", "blade" } },
	htmx = { filetypes = { "html", "blade" } },
	gopls = {},
}
for server, config in pairs(servers) do
	vim.lsp.config(server, config)
	vim.lsp.enable(server)
end

vim.api.nvim_create_autocmd("LspAttach", {
	group = vim.api.nvim_create_augroup("UserConfigLsp", {}),
	callback = function(ev)
		vim.keymap.set("n", "gD", vim.lsp.buf.declaration, { buffer = ev.buf, desc = "go to declaration" })
		vim.keymap.set("n", "gd", vim.lsp.buf.definition, { buffer = ev.buf, desc = "go to definition" })
		-- vim.keymap.set("n", "gi", vim.lsp.buf.implementaion, { buffer = ev.buf, desc = "go to implementation" })
		vim.keymap.set("n", "<leader>rn", vim.lsp.buf.rename, { buffer = ev.buf, desc = "lsp rename" })
		vim.keymap.set("n", "<leader>a", vim.lsp.buf.code_action, { buffer = ev.buf, desc = "code action" })
		vim.keymap.set({ "n", "i" }, "<C-k>", vim.lsp.buf.signature_help, { buffer = ev.buf, desc = "signature help" })
		vim.keymap.set("n", "gr", vim.lsp.buf.references, { buffer = ev.buf, desc = "references" })
	end,
})

local snacks = require("snacks")
snacks.setup({
	bigfile = {},
	dim = {},
	image = {},
	indent = {},
	lazygit = {},
	picker = {},
	quickfile = {},
	notifier = {},
})
vim.keymap.set("n", "<leader>tf", function()
	snacks.picker.grep()
end, { desc = "grep picker" })
vim.keymap.set("n", "<leader>te", snacks.picker.files, { desc = "file picker" })
vim.keymap.set("n", "<leader>lg", function()
	snacks.lazygit()
end, { desc = "lazygit" })

local leap = require("leap")
leap.opts.preview = function(ch0, ch1, ch2)
	return not (ch1:match("%s") or (ch0:match("%a") and ch1:match("%a") and ch2:match("%a")))
end
leap.opts.equivalence_classes = {
	" \t\r\n",
	"([{",
	")]}",
	"'\"`",
}
vim.api.nvim_set_hl(0, "LeapBackdrop", { link = "Comment" })

do
	-- Return an argument table for `leap()`, tailored for f/t-motions.
	local function as_ft(key_specific_args)
		local common_args = {
			inputlen = 1,
			inclusive = true,
			-- To limit search scope to the current line:
			-- pattern = function (pat) return '\\%.l'..pat end,
			opts = {
				labels = "", -- force autojump
				safe_labels = vim.fn.mode(1):match("[no]") and "" or nil, -- [1]
			},
		}
		return vim.tbl_deep_extend("keep", common_args, key_specific_args)
	end

	local clever = require("leap.user").with_traversal_keys -- [2]
	local clever_f = clever("f", "F")
	local clever_t = clever("t", "T")

	for key, key_specific_args in pairs({
		f = { opts = clever_f },
		F = { backward = true, opts = clever_f },
		t = { offset = -1, opts = clever_t },
		T = { backward = true, offset = 1, opts = clever_t },
	}) do
		vim.keymap.set({ "n", "x", "o" }, key, function()
			require("leap").leap(as_ft(key_specific_args))
		end)
	end
end

vim.api.nvim_create_autocmd("CmdlineLeave", {
	group = vim.api.nvim_create_augroup("LeapOnSearch", {}),
	callback = function()
		local ev = vim.v.event
		local is_search_cmd = (ev.cmdtype == "/") or (ev.cmdtype == "?")
		local cnt = vim.fn.searchcount().total
		if is_search_cmd and not ev.abort and (cnt > 1) then
			-- Allow CmdLineLeave-related chores to be completed before
			-- invoking Leap.
			vim.schedule(function()
				-- We want "safe" labels, but no auto-jump (as the search
				-- command already does that), so just use `safe_labels`
				-- as `labels`, with n/N removed.
				local labels = require("leap").opts.safe_labels:gsub("[nN]", "")
				-- For `pattern` search, we never need to adjust conceallevel
				-- (no user input). We cannot merge `nil` from a table, but
				-- using the option's current value has the same effect.
				local vim_opts = { ["wo.conceallevel"] = vim.wo.conceallevel }
				require("leap").leap({
					pattern = vim.fn.getreg("/"), -- last search pattern
					windows = { vim.fn.win_getid() },
					opts = { safe_labels = "", labels = labels, vim_opts = vim_opts },
				})
			end)
		end
	end,
})

vim.keymap.set({ "n", "x", "o" }, "s", "<Plug>(leap)", { desc = "leap" })
vim.keymap.set({ "n", "x", "o" }, "S", "<Plug>(leap-from-window)", { desc = "leap across window" })