-- Options
----------

vim.o.undofile = true
vim.o.backup = true
vim.cmd "set backupdir-=."

vim.cmd "set shortmess+=c"

vim.o.mouse = "a"

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

vim.o.smartindent = true

-- tabstop and shiftwidth are set locally by individual filetypes

vim.o.inccommand = "split"

vim.o.scrolloff = 1
vim.o.sidescrolloff = 5

vim.o.colorcolumn = "80"
vim.o.cursorline = true

vim.o.title = true

vim.o.wildmode = "longest:full,full"
vim.o.completeopt = "menu,menuone,preview,noinsert,noselect"

-- Use ripgrep
vim.o.grepprg = vim.g.ripgrep_path .. " --vimgrep --smart-case"
vim.o.grepformat = "%f:%l:%c:%m," .. vim.o.grepformat

vim.o.termguicolors = true
vim.o.background = "dark"

-- Mode already shown by the status line
vim.o.showmode = false

-- Do not set "trail:-" because it messes up the highlighting
vim.o.listchars = "tab:│ ,extends:>,precedes:<,nbsp:+"
vim.wo.list = true
vim.o.fillchars = "fold:─,vert:│"

-- Leaders
----------

vim.g.maplocalleader = ","
vim.g.mapleader = ";"

-- Misc
-------

-- From neovim#14420
-- Restores the position of previously opened files
vim.cmd [[
	augroup LastCursorPos
		autocmd!
		autocmd BufReadPost * if @% !~# "\.git[\/\\]COMMIT_EDITMSG$" && line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g`\"" | endif
	augroup end
]]

-- Highlight yanked text
vim.cmd "autocmd TextYankPost * silent! lua vim.highlight.on_yank()"

vim.g.tex_flavor = "latex"

vim.g.gruvbox_italic = 1
vim.cmd "colorscheme gruvbox"

-- Mappings
-----------

local map = vim.api.nvim_set_keymap
local mapopts = { noremap = true, silent = true }

vim.fn["camelcasemotion#CreateMotionMappings"] "<LocalLeader>"

map("n", "=of", [[:set <C-R>=(&formatoptions =~ "a") ? 'formatoptions-=a' : 'formatoptions+=a'<CR><CR>]], mapopts)

-- Plugins
----------

-- Gitsigns

require('gitsigns').setup {
	keymaps = {
		noremap = true,
		buffer = true,
		silent = true,

		['n ]c'] = { expr = true, "&diff ? ']c' : '<cmd>lua require\"gitsigns\".next_hunk()<CR>'"},
		['n [c'] = { expr = true, "&diff ? '[c' : '<cmd>lua require\"gitsigns\".prev_hunk()<CR>'"},

		['n <leader>hs'] = '<cmd>lua require"gitsigns".stage_hunk()<CR>',
		['n <leader>hu'] = '<cmd>lua require"gitsigns".undo_stage_hunk()<CR>',
		['n <leader>hr'] = '<cmd>lua require"gitsigns".reset_hunk()<CR>',
		['n <leader>hR'] = '<cmd>lua require"gitsigns".reset_buffer()<CR>',
		['n <leader>hp'] = '<cmd>lua require"gitsigns".preview_hunk()<CR>',
		['n <leader>hb'] = '<cmd>lua require"gitsigns".blame_line()<CR>',

		-- Text objects
		['o ih'] = ':<C-U>lua require"gitsigns".select_hunk()<CR>',
		['x ih'] = ':<C-U>lua require"gitsigns".select_hunk()<CR>',
	}
}

-- Treesitter

require('nvim-treesitter.configs').setup {
	highlight = {
		enable = true,
	},
	incremental_selection = {
		enable = true,
		keymaps = {
			init_selection = "gnn",
			node_incremental = "grn",
			scope_incremental = "grc",
			node_decremental = "grm",
		},
	},
	indent = {
		enable = true,
		disable = { "rust" },
	},
	matchup = {
		enable = true,
	},
	textobjects = {
		select = {
			enable = true,
			keymaps = {
				-- You can use the capture groups defined in textobjects.scm
				["af"] = "@function.outer",
				["if"] = "@function.inner",
				["ac"] = "@class.outer",
				["ic"] = "@class.inner",
			},
		},

		move = {
			enable = true,
			goto_next_start = {
				["]m"] = "@function.outer",
				["]]"] = "@class.outer",
			},
			goto_next_end = {
				["]M"] = "@function.outer",
				["]["] = "@class.outer",
			},
			goto_previous_start = {
				["[m"] = "@function.outer",
				["[["] = "@class.outer",
			},
			goto_previous_end = {
				["[M"] = "@function.outer",
				["[]"] = "@class.outer",
			},
		},
	},
}

vim.o.foldmethod = 'expr'
vim.o.foldexpr = 'nvim_treesitter#foldexpr()'

-- nvim-cmp

local cmp = require("cmp")

cmp.setup {
	snippet = {
		expand = function(args)
			vim.fn["vsnip#anonymous"](args.body)
		end,
	},
	mapping = cmp.mapping.preset.insert({
		['<CR>'] = cmp.mapping.confirm({ select = false }),
	}),
	sources = cmp.config.sources({
		{ name = "nvim_lsp" },
		{ name = "vsnip" },
		{ name = "latex_symbols" },
		{ name = "calc" },
	}, {
			{ name = "path" },
			{ name = "treesitter" },
	}, {
			{ name = "tmux" },
			{ name = "spell" },
			-- Use \k for iskeyword because of UTF-8
			{ name = "buffer", option = { keyword_pattern = [[\k\+]], } },
	}),
}

cmp.setup.cmdline("/", {
	sources = {
		{ name = "buffer", option = { keyword_pattern = [[\k\+]], } },
	},
	mapping = cmp.mapping.preset.cmdline({}),
})

cmp.setup.cmdline(":", {
	sources = cmp.config.sources({
			{ name = "cmdline" },
	}),
	mapping = cmp.mapping.preset.cmdline({}),
})

-- Telescope

require("telescope").setup {
	extensions = {
		file_browser = {
			path = "%:p:h",
			dir_icon = "D",
		},
		["ui-select"] = {
			require("telescope.themes").get_dropdown {}
		}
	}
}

require("telescope").load_extension "file_browser"
require("telescope").load_extension "ui-select"

map("n", "<leader>fb", "<cmd>Telescope buffers<cr>", mapopts)
map("n", "<leader>ff", "<cmd>Telescope find_files<cr>", mapopts)
map("n", "<leader>fg", "<cmd>Telescope live_grep<cr>", mapopts)
map("n", "<leader>fh", "<cmd>Telescope help_tags<cr>", mapopts)
map("n", "<leader>fo", "<cmd>Telescope oldfiles<cr>", mapopts)
map("n", "<leader>fs", "<cmd>Telescope spell_suggest<cr>", mapopts)
map("n", "<leader>ft", "<cmd>Telescope treesitter<cr>", mapopts)
map("n", "-", "<cmd>lua require('telescope').extensions.file_browser.file_browser()<cr>", mapopts)

-- Lualine

require("lualine").setup {
	options = {
		component_separators = "",
		icons_enabled = false,
		section_separators = "",
	},
	sections = {
		lualine_c = {
			'filename',
			{
				'lsp_progress',
				display_components = { 'lsp_client_name', { 'title', 'percentage', 'message' } },
			},
		},
	},
}

-- VSnip

map("i", "<Tab>", "vsnip#jumpable(1) ? '<Plug>(vsnip-jump-next)' : '<Tab>'", { silent = true, expr = true })
map("s", "<Tab>", "vsnip#jumpable(1) ? '<Plug>(vsnip-jump-next)' : '<Tab>'", { silent = true, expr = true })

map("i", "<S-Tab>", "vsnip#jumpable(-1) ? '<Plug>(vsnip-jump-prev)' : '<Tab>'", { silent = true, expr = true })
map("s", "<S-Tab>", "vsnip#jumpable(-1) ? '<Plug>(vsnip-jump-prev)' : '<Tab>'", { silent = true, expr = true })

-- OSCyank

-- Text yanked into the "t register gets copied using OSC52 escape sequences
-- (e.g. goes through SSH)
vim.cmd "autocmd TextYankPost * if v:event.regname is 't' | OSCYankReg t | endif"

-- Diffview

require("diffview").setup {
	use_icons = false,
	enhanced_diff_hl = true,
}

-- Neogit

require("neogit").setup {
	signs = {
		section = { "", "" },
		item = { "", "" },
	},
	integrations = {
		diffview = true,
	},
}

-- Notify

vim.cmd [[highlight link NotifyERRORBorder DiagnosticError]]
vim.cmd [[highlight link NotifyERRORIcon DiagnosticError]]
vim.cmd [[highlight link NotifyERRORTitle DiagnosticError]]

vim.cmd [[highlight link NotifyWARNBorder DiagnosticWarn]]
vim.cmd [[highlight link NotifyWARNIcon DiagnosticWarn]]
vim.cmd [[highlight link NotifyWARNTitle DiagnosticWarn]]

vim.cmd [[highlight link NotifyINFOBorder DiagnosticInfo]]
vim.cmd [[highlight link NotifyINFOIcon DiagnosticInfo]]
vim.cmd [[highlight link NotifyINFOTitle DiagnosticInfo]]

vim.cmd [[highlight link NotifyDEBUGBorder DiagnosticHint]]
vim.cmd [[highlight link NotifyDEBUGIcon DiagnosticHint]]
vim.cmd [[highlight link NotifyDEBUGTitle DiagnosticHint]]

vim.cmd [[highlight link NotifyDEBUGBorder GruvboxPurple]]
vim.cmd [[highlight link NotifyDEBUGIcon GruvboxPurple]]
vim.cmd [[highlight link NotifyDEBUGTitle GruvboxPurple]]

vim.notify = require("notify")

-- Comment

require('Comment').setup {}

-- Local config

function isModuleAvailable(name)
  if package.loaded[name] then
    return true
  else
    for _, searcher in ipairs(package.searchers or package.loaders) do
      local loader = searcher(name)
      if type(loader) == 'function' then
        package.preload[name] = loader
        return true
      end
    end
    return false
  end
end

if isModuleAvailable("local_config") then
	require("local_config")
end