local vim = _G["vim"]
local util = require("util")

local Plug = vim.fn["plug#"]
vim.call("plug#begin")
	Plug("neoclide/coc.nvim", { ["do"] = vim.fn["coc#util#install()"]})
	Plug("nvim-treesitter/nvim-treesitter", { ["do"] = vim.fn["TSUpdate"]})
	Plug("Shirk/vim-gas")
	Plug("Sirsireesh/vim-dlang-phobos-highlighter")
	Plug("airblade/vim-gitgutter")
	Plug("frazrepo/vim-rainbow")
	Plug("nvim-lualine/lualine.nvim")
	Plug("junegunn/vim-easy-align")
	Plug("junegunn/vim-peekaboo")
	Plug("michaeljsmith/vim-indent-object")
	Plug("sheerun/vim-polyglot")
	Plug("tikhomirov/vim-glsl")
	Plug("tomasr/molokai")
	Plug("tpope/vim-commentary")
	Plug("tpope/vim-eunuch")
	Plug("tpope/vim-repeat")
	Plug("tpope/vim-surround")
	Plug("tpope/vim-fugitive")
	Plug("tbastos/vim-lua")
	Plug("yuezk/vim-js")
	Plug("ctrlpvim/ctrlp.vim")
	Plug("ryanoasis/vim-webdevicons")
	Plug("kylelaker/riscv.vim")
	Plug("dart-lang/dart-vim-plugin")
	Plug("JuliaEditorSupport/julia-vim")
	Plug("godlygeek/tabular")
	Plug("preservim/vim-markdown")
	Plug("dense-analysis/ale")
	Plug("nvim-tree/nvim-web-devicons")
	Plug("lewis6991/gitsigns.nvim")
	Plug("BurntSushi/ripgrep")
	Plug("nvim-lua/plenary.nvim")
	Plug("nvim-telescope/telescope.nvim", { tag = "master" })
	Plug("nanozuki/tabby.nvim")
	Plug("petertriho/nvim-scrollbar")
	Plug("neovim/nvim-lspconfig")
vim.call("plug#end")

require("lualine").setup({
	options = {
		theme = "modus-vivendi",
	},
})

require("nvim-treesitter.configs").setup({
	ensure_installed = "all",
	sync_install = false,
	auto_install = true,
	sign_column_always = true,
	disable_lsp = true,
	use_neovim_diagnostics_api = true,
	highlight = {
		enable = true,
		additional_vim_regex_highlighting = true,
	},
	indent = {
		enable = false
	}
})
vim.wo.foldmethod = "expr"
vim.wo.foldexpr = "v:lua.vim.treesitter.foldexpr()"

-- local lspconfig = require('lspconfig')

--lspconfig.lua_ls.setup {
--	settings = {
--		Lua = {
--			runtime = {
--				-- Tell the language server which version of Lua you're using
--				-- (most likely LuaJIT in the case of Neovim)
--				version = 'LuaJIT',
--			},
--			diagnostics = {
--				-- Get the language server to recognize the `vim` global
--				globals = {
--					'vim',
--					'require'
--				},
--			},
--			workspace = {
--				-- Make the server aware of Neovim runtime files
--				library = vim.api.nvim_get_runtime_file("", true),
--			},
--			-- Do not send telemetry data containing a randomized but unique identifier
--			telemetry = {
--				enable = false,
--			},
--		},
--	},
--}

local devicons = require("nvim-web-devicons")
devicons.setup({
	override = {
		sdl = {
			color = "#4f88dd",
			name = "SDLang",
			icon = "󰈮",
		},
		d = {
			color = "#fa645a",
			name = "D",
			icon = ""
		},
	};
})

-- require("ale").setup({
-- 	completion_enabled = false,
-- 	maximum_file_size = 1024 * 1024 * 8,
-- 	fix_on_save = true,
-- 	-- linters_explicit = true,
-- 	-- linters = {},
-- 	linters_disable = {
-- 		"dls", "dmd", "luacheck", "lua_language_server", "luac", "selene"
-- 	},
-- 	linters_ignore = {
-- 		"dls", "dmd", "luacheck", "lua_language_server", "luac", "selene"
-- 	},
-- 	fixers = {
-- 		["*"] = "trim_whitespace",
-- 		markdown = "prettier",
-- 		json = "prettier",
-- 	},
-- 	lua_language_server_config = {

-- 	}
-- })

-- vim.g["g:airline#extensions#ale#enabled"] = 1
-- vim.g["airline#extensions#tabline#enabled"] = 0
-- vim.g["airline#extensions#tabline#show_close_button"] = 0
-- vim.g["airline#extensions#tabline#tabs_label"] = ""
-- vim.g["airline#extensions#tabline#buffers_label"] = ""
-- vim.g["airline#extensions#tabline#formatter"] = "unique_tail_improved"
-- vim.g.airline_theme = "bubblegum"
-- vim.g.airline_powerline_fonts = 1
-- vim.g.airline_skip_empty_sections = 1
-- vim.g.airline_section_z = "%l:%c/%L %p%%"

vim.g.rainbow_guifgs = { "#dddddd", "#bbbbbb", "#cccccc", "#aaaaaa" }

-- require("barbar").setup({
-- 	highlight_inactive_file_icons = true,
-- 	clickable = false,
-- 	maximum_padding = 0,
-- 	semantic_letters = true,
-- 	icons = {
-- 		inactive = { button = "" },
-- 		current = { button = "" },
-- 	},
-- })

do
	local theme = {
		fill = { bg = "#333333", fg = "#b2b2b2" },
		head = "TabLine",
		tab = "TabLine",
		win = "TabLine",
		tail = "TabLine",
	}
	require("tabby").setup({
		line = function(line)
			return {
				{ "  ", hl = { bg = theme.fill.bg, fg = theme.fill.fg } },
				line.tabs().foreach(function(tab, i)
					local hl = { bg = theme.fill.bg, fg = theme.fill.fg }
					local buf = tab.current_win().buf()
					local _, typeColour = devicons.get_icon_color(buf.name())
					typeColour = typeColour or hl.fg
					typeColour = util.lightenColour(typeColour, 100)
					if tab.is_current() then
						hl.fg = hl.bg
						hl.bg = typeColour
					else
						hl.fg = typeColour
						if i % 2 == 1 then
							hl.bg = "#252525"
						end
					end
					return {
						line.sep("", hl, theme.fill),
						#buf.file_icon() > 0 and buf.file_icon() or "",
						{ tab.name(), hl = { fg = hl.fg, bg = hl.bg, style = buf.is_changed() and "underline" or "" } },
						line.sep("", hl, theme.fill),
						hl = hl,
						margin = " ",
					}
				end),
				line.spacer(),
				hl = theme.fill,
			}
		end,
	})
end

local builtin = require('telescope.builtin')
vim.keymap.set("n", ",ff", builtin.find_files, { desc = "Telescope find files" })
vim.keymap.set("n", ",fg", builtin.live_grep, { desc = "Telescope live grep" })
vim.keymap.set("n", ",fh", builtin.help_tags, { desc = "Telescope help tags" })
vim.keymap.set("n", ",fb", builtin.current_buffer_fuzzy_find, { desc = "Telescope fzf" })


local actions = require("telescope.actions")
require("telescope").setup({
		pickers = {
		buffers = {
			mappings = {
				i = { ["<CR>"] = actions.select_tab_drop }
			}
		},
		find_files = {
			mappings = {
				i = { ["<CR>"] = actions.select_tab_drop }
			}
		},
		git_files = {
			mappings = {
				i = { ["<CR>"] = actions.select_tab_drop }
			}
		},
		old_files = {
			mappings = {
				i = { ["<CR>"] = actions.select_tab_drop }
			}
		},
	},
})

do -- COC
	-- Some servers have issues with backup files, see #649
	vim.opt.backup = false
	vim.opt.writebackup = false

	-- Having longer updatetime (default is 4000 ms = 4s) leads to noticeable
	-- delays and poor user experience
	vim.opt.updatetime = 500

	-- Always show the signcolumn, otherwise it would shift the text each time
	-- diagnostics appeared/became resolved
	vim.opt.signcolumn = "yes"

	local keyset = vim.keymap.set
	-- Autocomplete
	function _G.check_back_space()
		local col = vim.fn.col('.') - 1
		return col == 0 or vim.fn.getline('.'):sub(col, col):match('%s') ~= nil
	end

	-- Use Tab for trigger completion with characters ahead and navigate
	-- NOTE: There's always a completion item selected by default, you may want to enable
	-- no select by setting `"suggest.noselect": true` in your configuration file
	-- NOTE: Use command ':verbose imap <tab>' to make sure Tab is not mapped by
	-- other plugins before putting this into your config
	local opts = {silent = true, noremap = true, expr = true, replace_keycodes = false}
	keyset("i", "<TAB>", 'coc#pum#visible() ? coc#pum#next(1) : v:lua.check_back_space() ? "<TAB>" : coc#refresh()', opts)
	keyset("i", "<S-TAB>", [[coc#pum#visible() ? coc#pum#prev(1) : "\<C-h>"]], opts)

	-- Make <CR> to accept selected completion item or notify coc.nvim to format
	-- <C-g>u breaks current undo, please make your own choice
	keyset("i", "<cr>", [[coc#pum#visible() ? coc#pum#confirm() : "\<C-g>u\<CR>\<c-r>=coc#on_enter()\<CR>"]], opts)

	-- Use <c-j> to trigger snippets
	keyset("i", "<c-j>", "<Plug>(coc-snippets-expand-jump)")
	-- Use <c-space> to trigger completion
	keyset("i", "<c-space>", "coc#refresh()", {silent = true, expr = true})

	-- Use `[g` and `]g` to navigate diagnostics
	-- Use `:CocDiagnostics` to get all diagnostics of current buffer in location list
	keyset("n", "ge", "<Plug>(coc-diagnostic-prev)", {silent = true})
	keyset("n", "gE", "<Plug>(coc-diagnostic-next)", {silent = true})

	-- GoTo code navigation
	keyset("n", "gd", "<Plug>(coc-definition)", {silent = true})
	keyset("n", "gy", "<Plug>(coc-type-definition)", {silent = true})
	keyset("n", "gi", "<Plug>(coc-implementation)", {silent = true})
	keyset("n", "gr", "<Plug>(coc-references)", {silent = true})


	-- Use K to show documentation in preview window
	function _G.show_docs()
		local cw = vim.fn.expand('<cword>')
		if vim.fn.index({'vim', 'help'}, vim.bo.filetype) >= 0 then
			vim.api.nvim_command('h ' .. cw)
		elseif vim.api.nvim_eval('coc#rpc#ready()') then
			vim.fn.CocActionAsync('doHover')
		else
			vim.api.nvim_command('!' .. vim.o.keywordprg .. ' ' .. cw)
		end
	end
	keyset("n", "K", '<CMD>lua _G.show_docs()<CR>', {silent = true})


	-- Highlight the symbol and its references on a CursorHold event(cursor is idle)
	vim.api.nvim_create_augroup("CocGroup", {})
	vim.api.nvim_create_autocmd("CursorHold", {
		group = "CocGroup",
		command = "silent call CocActionAsync('highlight')",
		desc = "Highlight symbol under cursor on CursorHold"
	})


	-- Symbol renaming
	keyset("n", "<leader>rn", "<Plug>(coc-rename)", {silent = true})


	-- Formatting selected code
	keyset("x", "<leader>f", "<Plug>(coc-format-selected)", {silent = true})
	keyset("n", "<leader>f", "<Plug>(coc-format-selected)", {silent = true})


	-- Setup formatexpr specified filetype(s)
	vim.api.nvim_create_autocmd("FileType", {
		group = "CocGroup",
		pattern = "typescript,json",
		command = "setl formatexpr=CocAction('formatSelected')",
		desc = "Setup formatexpr specified filetype(s)."
	})

	-- Update signature help on jump placeholder
	vim.api.nvim_create_autocmd("User", {
		group = "CocGroup",
		pattern = "CocJumpPlaceholder",
		command = "call CocActionAsync('showSignatureHelp')",
		desc = "Update signature help on jump placeholder"
	})

	-- Apply codeAction to the selected region
	-- Example: `<leader>aap` for current paragraph
	opts = {silent = true, nowait = true}
	keyset("x", "<leader>a", "<Plug>(coc-codeaction-selected)", opts)
	keyset("n", "<leader>a", "<Plug>(coc-codeaction-selected)", opts)

	-- Remap keys for apply code actions at the cursor position.
	keyset("n", "<leader>ac", "<Plug>(coc-codeaction-cursor)", opts)
	-- Remap keys for apply source code actions for current file.
	keyset("n", "<leader>as", "<Plug>(coc-codeaction-source)", opts)
	-- Apply the most preferred quickfix action on the current line.
	keyset("n", "<leader>qf", "<Plug>(coc-fix-current)", opts)

	-- Remap keys for apply refactor code actions.
	keyset("n", "<leader>re", "<Plug>(coc-codeaction-refactor)", { silent = true })
	keyset("x", "<leader>r", "<Plug>(coc-codeaction-refactor-selected)", { silent = true })
	keyset("n", "<leader>r", "<Plug>(coc-codeaction-refactor-selected)", { silent = true })

	-- Run the Code Lens actions on the current line
	keyset("n", "<leader>cl", "<Plug>(coc-codelens-action)", opts)


	-- Map function and class text objects
	-- NOTE: Requires 'textDocument.documentSymbol' support from the language server
	keyset("x", "if", "<Plug>(coc-funcobj-i)", opts)
	keyset("o", "if", "<Plug>(coc-funcobj-i)", opts)
	keyset("x", "af", "<Plug>(coc-funcobj-a)", opts)
	keyset("o", "af", "<Plug>(coc-funcobj-a)", opts)
	keyset("x", "ic", "<Plug>(coc-classobj-i)", opts)
	keyset("o", "ic", "<Plug>(coc-classobj-i)", opts)
	keyset("x", "ac", "<Plug>(coc-classobj-a)", opts)
	keyset("o", "ac", "<Plug>(coc-classobj-a)", opts)


	-- Remap <C-f> and <C-b> to scroll float windows/popups
	---@diagnostic disable-next-line: redefined-local
	local opts = {silent = true, nowait = true, expr = true}
	keyset("n", "<C-f>", 'coc#float#has_scroll() ? coc#float#scroll(1) : "<C-f>"', opts)
	keyset("n", "<C-b>", 'coc#float#has_scroll() ? coc#float#scroll(0) : "<C-b>"', opts)
	keyset("i", "<C-f>",
		'coc#float#has_scroll() ? "<c-r>=coc#float#scroll(1)<cr>" : "<Right>"', opts)
	keyset("i", "<C-b>",
		'coc#float#has_scroll() ? "<c-r>=coc#float#scroll(0)<cr>" : "<Left>"', opts)
	keyset("v", "<C-f>", 'coc#float#has_scroll() ? coc#float#scroll(1) : "<C-f>"', opts)
	keyset("v", "<C-b>", 'coc#float#has_scroll() ? coc#float#scroll(0) : "<C-b>"', opts)


	-- Use CTRL-S for selections ranges
	-- Requires 'textDocument/selectionRange' support of language server
	keyset("n", "<C-s>", "<Plug>(coc-range-select)", {silent = true})
	keyset("x", "<C-s>", "<Plug>(coc-range-select)", {silent = true})


	-- Add `:Format` command to format current buffer
	vim.api.nvim_create_user_command("Format", "call CocAction('format')", {})

	-- " Add `:Fold` command to fold current buffer
	vim.api.nvim_create_user_command("Fold", "call CocAction('fold', <f-args>)", {nargs = '?'})

	-- Add `:OR` command for organize imports of the current buffer
	vim.api.nvim_create_user_command("OR", "call CocActionAsync('runCommand', 'editor.action.organizeImport')", {})

	-- Add (Neo)Vim's native statusline support
	-- NOTE: Please see `:h coc-status` for integrations with external plugins that
	-- provide custom statusline: lightline.vim, vim-airline
	-- vim.opt.statusline:prepend("%{coc#status()}%{get(b:,'coc_current_function','')}")

	-- Mappings for CoCList
	-- code actions and coc stuff
	---@diagnostic disable-next-line: redefined-local
	local opts = {silent = true, nowait = true}
	-- Show all diagnostics
	keyset("n", "<space>a", ":<C-u>CocList diagnostics<cr>", opts)
	-- Manage extensions
	keyset("n", "<space>e", ":<C-u>CocList extensions<cr>", opts)
	-- Show commands
	keyset("n", "<space>c", ":<C-u>CocList commands<cr>", opts)
	-- Find symbol of current document
	keyset("n", "<space>o", ":<C-u>CocList outline<cr>", opts)
	-- Search workspace symbols
	keyset("n", "<space>s", ":<C-u>CocList -I symbols<cr>", opts)
	-- Do default action for next item
	keyset("n", "<space>j", ":<C-u>CocNext<cr>", opts)
	-- Do default action for previous item
	keyset("n", "<space>k", ":<C-u>CocPrev<cr>", opts)
	-- Resume latest coc list
	keyset("n", "<space>p", ":<C-u>CocListResume<cr>", opts)
end

require("scrollbar").setup()