-- functions for auto-complete
local has_words_before = function()
  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

local feedkey = function(key, mode)
  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true),
  mode, true)
end

-- LSP keybindings
local lsp_on_attach = function(_, bufnr)
	local nmap = function(keys, func, desc)
		if desc then
			desc = 'LSP: ' .. desc
		end

		vim.keymap.set('n', keys, func, { buffer = bufnr, desc = desc })
	end

	-- Define standard LSP shortcuts
	nmap('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')
	nmap('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction')
-- these actions are now handled by Telescope
--	nmap('gd', vim.lsp.buf.definition, '[G]oto [d]efinition')
--	nmap('gr', vim.lsp.buf.references, '[G]oto [R]eferences')
--	nmap('gc', vim.lsp.buf.outgoing_calls, '[G]oto Outgoing [C]alls')
--	nmap('gt', vim.lsp.buf.type_definition, '[G]oto [T]ype definition')
	-- See `:help K` for why this keymap
	nmap('K', vim.lsp.buf.hover, 'Hover Documentation')

	-- Create a command `:Format` local to the LSP buffer
	vim.api.nvim_buf_create_user_command(bufnr, 'Format',
		vim.lsp.buf.format or vim.lsp.buf.formatting,
		{ desc = 'Format current buffer with LSP' })
end

plugins = {
	{ "tpope/vim-sensible", lazy = false },
	{
		"EdenEast/nightfox.nvim",
		lazy = false,
		dependencies = {
			{ "airblade/vim-gitgutter" },
		},
		init = function()
			require('nightfox').setup({
				options = {
					modules = { gitgutter = true }
				},
				palettes = {
					nightfox = {
						bg0  = '#121212',
						bg1  = '#161616',
						bg2  = '#222222',
						bg3  = '#282828',
						bg4  = '#404040',
						sel0 = "#2a2a2a",
						sel1 = "#525253",
					}
				},
				specs = {
					nightfox = {
						syntax =  { func = "red" }
					}
				},
			})

			vim.o.termguicolors = true
			vim.cmd("colorscheme nightfox")
		end,
	},
	{
		"ojroques/nvim-hardline",
		lazy = false,
		init = function()
			require('hardline').setup()
		end,
	},
	{
		"kevinhwang91/rnvimr",
		lazy = false,
		init = function()
			vim.api.nvim_set_keymap('n', '<leader>f', ":RnvimrToggle<cr>", {})
			vim.g.rnvimr_action = {
				['<C-t>'] = "NvimEdit tabedit",
				['<C-x>'] = "NvimEdit split",
				['<C-v>'] = "NvimEdit vsplit",
			}
		end,
	},
	{
		"hrsh7th/nvim-cmp",
		lazy = false,
		dependencies =  {
			{ "hrsh7th/cmp-nvim-lsp" },
        	{ "hrsh7th/cmp-buffer" },
        	{ "hrsh7th/cmp-path" },
        	{ "hrsh7th/cmp-cmdline" },
			{ "hrsh7th/cmp-nvim-lsp-signature-help" },
			{ "hrsh7th/cmp-vsnip" },
        	{ "hrsh7th/vim-vsnip" },
		},
		init = function()
			vim.o.completeopt = "menu,menuone,noselect"
			local cmp = require("cmp")

			cmp.setup({
				snippet = {
					-- snippet engine is required
					expand = function(args)
						vim.fn["vsnip#anonymous"](args.body) -- For `vsnip` users.
					end,
				},
				window = {
					-- completion = cmp.config.window.bordered(),
					-- documentation = cmp.config.window.bordered(),
				},
				mapping = cmp.mapping.preset.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 }),
					["<Tab>"] = cmp.mapping(function(fallback)
						if cmp.visible() then
							cmp.select_next_item()
						elseif vim.fn["vsnip#available"](1) == 1 then
							feedkey("<Plug>(vsnip-expand-or-jump)", "")
						elseif has_words_before() then
							cmp.complete()
						else
							-- The fallback function sends a already mapped key.
							-- In this case, it's probably `<Tab>`.
							fallback()
						end
					end, { "i", "s" }),
					["<S-Tab>"] = cmp.mapping(function()
						if cmp.visible() then
							cmp.select_prev_item()
						elseif vim.fn["vsnip#jumpable"](-1) == 1 then
							feedkey("<Plug>(vsnip-jump-prev)", "")
						end
					end, { "i", "s" }),

				}),
				sources = cmp.config.sources({
					{ name = 'nvim_lsp' },
					{ name = 'nvim_lsp_signature_help' },
					{ name = 'vsnip' },
				}, {
					{ name = 'buffer' },
				})
			})
			-- Set configuration for specific filetype.
			cmp.setup.filetype('gitcommit', {
				sources = cmp.config.sources({
					{ name = 'cmp_git' },
				}, {
					{ name = 'buffer' },
				})
			})

			-- Use buffer source for `/` and `?`
			cmp.setup.cmdline({ '/', '?' }, {
				mapping = cmp.mapping.preset.cmdline(),
				sources = {
					{ name = 'buffer' }
				}
			})

			-- Use cmdline & path source for ':'
			cmp.setup.cmdline(':', {
				mapping = cmp.mapping.preset.cmdline(),
				sources = cmp.config.sources({
					{ name = 'path' }
				}, {
					{ name = 'cmdline' }
				})
			})
		end,
	},
	{
		"neovim/nvim-lspconfig",
		lazy = false,
		dependencies = "hrsh7th/nvim-cmp",
		init = function()
			local capabilities =  require("cmp_nvim_lsp").default_capabilities()
			local lsp_config = require("lspconfig")
			local servers = { "clangd", "rust_analyzer", "pylsp" }

			for _, lsp in ipairs(servers) do
				lsp_config[lsp].setup {
					capabilities = capabilities,
					on_attach = lsp_on_attach,
				}
			end
		end,
	},
	{
		"nvim-telescope/telescope.nvim",
		tag = "0.1.2",
		lazy = false,
		dependencies = {
			{ "nvim-lua/plenary.nvim" },
			{ "ludovicchabant/vim-gutentags" },
			{ "nvim-telescope/telescope-fzf-native.nvim", build = "make" },
		},
		init = function()
			require("telescope").setup{
				defaults = {
					-- Default configuration for telescope goes here:
					-- config_key = value,
					mappings = {
						i = {
							-- map actions.which_key to <C-h> (default: <C-/>)
							-- actions.which_key shows the mappings for your picker,
							-- e.g. git_{create, delete, ...}_branch for the git_branches picker
							["<C-h>"] = "which_key"
						}
					}
				},
				pickers = {
					-- Default configuration for builtin pickers goes here:
					-- picker_name = {
						--   picker_config_key = value,
						--   ...
						-- }
						-- Now the picker_config_key will be applied every time you call this
						-- builtin picker
				},
				extensions = {
					fzf = {
						fuzzy = true,                    -- false will only do exact matching
						override_generic_sorter = true,  -- override the generic sorter
						override_file_sorter = true,     -- override the file sorter
						case_mode = "smart_case",        -- or "ignore_case" or "respect_case"
						-- the default case_mode is "smart_case"
					},
				}
			}
			require("telescope").load_extension("fzf")

			vim.api.nvim_set_keymap('n', 'tf',
				":Telescope find_files<cr>", {})
			vim.api.nvim_set_keymap('n', 'tg',
				":Telescope live_grep<cr>", {})
			vim.api.nvim_set_keymap('n', 'ts',
				":Telescope grep_string<cr>", {})
			vim.api.nvim_set_keymap('n', 'tt',
				":Telescope current_buffer_tags<cr>", {})
			vim.api.nvim_set_keymap('n', 'tc',
				":Telescope git_commits<cr>", {})
			vim.api.nvim_set_keymap('n', 'ta',
				":Telescope git_status<cr>", {})
			vim.api.nvim_set_keymap('n', 'td',
				":Telescope lsp_definitions<cr>", {})
			vim.api.nvim_set_keymap('n', 'tr',
				":Telescope lsp_references<cr>", {})
			vim.api.nvim_set_keymap('n', 'tl',
				":Telescope lsp_document_symbols<cr>", {})
			vim.api.nvim_set_keymap('n', 'te',
				":Telescope diagnostics<cr>", {})
		end,
	},
	{
		"airblade/vim-gitgutter",
		lazy = false,
		dependencies = {
			{ "tpope/vim-fugitive" },
		},
		init = function()
			-- put  sign in number column to avoid screen-shifting
			vim.cmd('set signcolumn=number')
		end,
	},
	{
		"sindrets/diffview.nvim",
		lazy = false,
		dependencies = {
			{ "nvim-lua/plenary.nvim" },
		},
		init = function()
			vim.api.nvim_set_keymap('n', '<leader>g', ":DiffviewOpen",  {})
		end,
	},
	{
		"nvim-treesitter/nvim-treesitter",
		lazy = false,
		init = function()
			local conf = require("nvim-treesitter.configs")

			conf.setup {
				-- only enable tested parsers
				ensure_installed = { "c", "cpp", "lua", "rust" },
				-- Install parsers synchronously (only applied to `ensure_installed`)
				sync_install = false,
				-- Automatically install missing parsers when entering buffer
				auto_install = false,
				-- List of parsers to ignore installing (for "all")
				ignore_install = {},
				highlight = {
					-- `false` will disable the whole extension
					enable = true,
					-- list of language that will be disabled
					disable = {},
					-- disable slow treesitter highlight for large files
					disable = function(lang, buf)
						local max_filesize = 200 * 1024 -- 200 KB
						local ok, stats =
						pcall(vim.loop.fs_stat, vim.api.nvim_buf_get_name(buf))
						if ok and stats and stats.size > max_filesize then
							return true
						end
					end,
					-- run `:h syntax` and tree-sitter at the same time.
					additional_vim_regex_highlighting = false,
				}
			}
		end,
	},
	{ "ARM9/arm-syntax-vim", lazy = false },
}

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable", -- latest stable release
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup(plugins, opts)