-- LSP Plugins
return {
	{
		-- `lazydev` configures Lua LSP for your Neovim config, runtime and plugins
		-- used for completion, annotations and signatures of Neovim apis
		"folke/lazydev.nvim",
		ft = "lua",
		opts = {
			library = {
				-- Load luvit types when the `vim.uv` word is found
				{ path = "luvit-meta/library", words = { "vim%.uv" } },
			},
		},
	},
	{ "Bilal2453/luvit-meta", lazy = true },
	{
		-- Main LSP Configuration
		"neovim/nvim-lspconfig",
		opts = {
			inlay_hints = { enabled = true },
			autoformat = false,
			format = {
				formatting_options = nil,
				timeout_ms = nil,
			},
		},
		dependencies = {
			-- Automatically install LSPs and related tools to stdpath for Neovim
			{ "williamboman/mason.nvim", config = true }, -- NOTE: Must be loaded before dependants
			"williamboman/mason-lspconfig.nvim",
			"WhoIsSethDaniel/mason-tool-installer.nvim",

			-- Useful status updates for LSP.
			-- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})`
			{ "j-hui/fidget.nvim", opts = {} },

			-- Allows extra capabilities provided by nvim-cmp
			"hrsh7th/cmp-nvim-lsp",
		},
		config = function()
			vim.lsp.config("vtsls", {
				filetypes = { "typescript", "javascript", "javascriptreact", "typescriptreact", "vue" },
				settings = {
					vtsls = { tsserver = { globalPlugins = {} } },
					typescript = {
						inlayHints = {
							includeInlayParameterNameHints = { enabled = true },
							includeInlayVariableTypeHints = { enabled = true },
							includeInlayPropertyDeclarationTypeHints = { enabled = true },
							includeInlayFunctionLikeReturnTypeHints = { enabled = true },
							includeInlayEnumMemberValueHints = { enabled = true },
						},
					},
				},
				before_init = function(_, config)
					table.insert(config.settings.vtsls.tsserver.globalPlugins, {
						name = "@vue/typescript-plugin",
						location = vim.fn.expand(
							"$MASON/packages/vue-language-server/node_modules/@vue/language-server"
						),
						languages = { "vue" },
						configNamespace = "typescript",
						enableForWorkspaceTypeScriptVersions = true,
					})
				end,
				on_attach = function(client)
					client.server_capabilities.documentFormattingProvider = false
					client.server_capabilities.documentRangeFormattingProvider = false
				end,
			})

			local capabilities = vim.lsp.protocol.make_client_capabilities()
			capabilities.textDocument.completion.completionItem.snippetSupport = true
			vim.lsp.config("emmet_language_server", {
				capabilities = capabilities,
				filetypes = { "html", "php", "blade" },
				init_options = {
					includeLanguages = {
						blade = "html",
					},
					html = {
						options = {
							["bem.enabled"] = true,
						},
					},
				},
			})

			vim.api.nvim_create_autocmd("LspAttach", {
				group = vim.api.nvim_create_augroup("kickstart-lsp-attach", { clear = true }),
				callback = function(event)
					-- NOTE: Remember that Lua is a real programming language, and as such it is possible
					-- to define small helper and utility functions so you don't have to repeat yourself.
					--
					-- In this case, we create a function that lets us more easily define mappings specific
					-- for LSP related items. It sets the mode, buffer and description for us each time.
					local map = function(keys, func, desc, mode)
						mode = mode or "n"
						vim.keymap.set(mode, keys, func, { buffer = event.buf, desc = "LSP: " .. desc })
					end

					-- Jump to the definition of the word under your cursor.
					--  This is where a variable was first declared, or where a function is defined, etc.
					--  To jump back, press <C-t>.
					map("gd", require("telescope.builtin").lsp_definitions, "[G]oto [D]efinition")

					-- Find references for the word under your cursor.
					map("gr", require("telescope.builtin").lsp_references, "[G]oto [R]eferences")

					-- Jump to the implementation of the word under your cursor.
					--  Useful when your language has ways of declaring types without an actual implementation.
					map("gI", require("telescope.builtin").lsp_implementations, "[G]oto [I]mplementation")

					-- Jump to the type of the word under your cursor.
					--  Useful when you're not sure what type a variable is and you want to see
					--  the definition of its *type*, not where it was *defined*.
					map("<leader>D", require("telescope.builtin").lsp_type_definitions, "Type [D]efinition")

					-- Fuzzy find all the symbols in your current document.
					--  Symbols are things like variables, functions, types, etc.
					map("<leader>ds", require("telescope.builtin").lsp_document_symbols, "[D]ocument [S]ymbols")

					-- Fuzzy find all the symbols in your current workspace.
					--  Similar to document symbols, except searches over your entire project.
					map("<leader>sm", require("telescope.builtin").lsp_dynamic_workspace_symbols, "[S]y[M]bols")
					-- Rename the variable under your cursor.
					--  Most Language Servers support renaming across files, etc.
					map("<leader>rn", vim.lsp.buf.rename, "[R]e[n]ame")

					-- Execute a code action, usually your cursor needs to be on top of an error
					-- or a suggestion from your LSP for this to activate.
					map("<leader>ca", vim.lsp.buf.code_action, "[C]ode [A]ction", { "n", "x" })

					-- WARN: This is not Goto Definition, this is Goto Declaration.
					--  For example, in C this would take you to the header.
					map("gD", vim.lsp.buf.declaration, "[G]oto [D]eclaration")

					-- The following two autocommands are used to highlight references of the
					-- word under your cursor when your cursor rests there for a little while.
					--    See `:help CursorHold` for information about when this is executed
					--
					-- When you move your cursor, the highlights will be cleared (the second autocommand).
					local client = vim.lsp.get_client_by_id(event.data.client_id)
					if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_documentHighlight) then
						local highlight_augroup =
							vim.api.nvim_create_augroup("kickstart-lsp-highlight", { clear = false })
						vim.api.nvim_create_autocmd({ "CursorHold", "CursorHoldI" }, {
							buffer = event.buf,
							group = highlight_augroup,
							callback = vim.lsp.buf.document_highlight,
						})

						vim.api.nvim_create_autocmd({ "CursorMoved", "CursorMovedI" }, {
							buffer = event.buf,
							group = highlight_augroup,
							callback = vim.lsp.buf.clear_references,
						})

						vim.api.nvim_create_autocmd("LspDetach", {
							group = vim.api.nvim_create_augroup("kickstart-lsp-detach", { clear = true }),
							callback = function(event2)
								vim.lsp.buf.clear_references()
								vim.api.nvim_clear_autocmds({ group = "kickstart-lsp-highlight", buffer = event2.buf })
							end,
						})
					end
					-- The following code creates a keymap to toggle inlay hints in your
					-- code, if the language server you are using supports them
					--
					-- This may be unwanted, since they displace some of your code
					if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_inlayHint) then
						map("<leader>th", function()
							vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({ bufnr = event.buf }))
						end, "[T]oggle Inlay [H]ints")
					end
				end,
			})

			-- Change diagnostic symbols in the sign column (gutter)
			-- if vim.g.have_nerd_font then
			--   local signs = { ERROR = '', WARN = '', INFO = '', HINT = '' }
			--   local diagnostic_signs = {}
			--   for type, icon in pairs(signs) do
			--     diagnostic_signs[vim.diagnostic.severity[type]] = icon
			--   end
			--   vim.diagnostic.config { signs = { text = diagnostic_signs } }
			-- end

			-- LSP servers and clients are able to communicate to each other what features they support.
			--  By default, Neovim doesn't support everything that is in the LSP specification.
			--  When you add nvim-cmp, luasnip, etc. Neovim now has *more* capabilities.
			--  So, we create new capabilities with nvim cmp, and then broadcast that to the servers.
			local capabilities = vim.lsp.protocol.make_client_capabilities()
			capabilities = vim.tbl_deep_extend("force", capabilities, require("cmp_nvim_lsp").default_capabilities())

			-- Enable the following language servers
			--  Feel free to add/remove any LSPs that you want here. They will automatically be installed.
			--
			--  Add any additional override configuration in the following tables. Available keys are:
			--  - cmd (table): Override the default command used to start the server
			--  - filetypes (table): Override the default list of associated filetypes for the server
			--  - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features.
			--  - settings (table): Override the default settings passed when initializing the server.
			--        For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/
			local servers = {
				clangd = {},
				gopls = {},
				pyright = {},
				ruff = {},
				emmet_language_server = {},
				svelte = {},
				html = {},
				cssls = {},
				cssmodules_ls = {},
				css_variables = {},
				jdtls = {},
				vtsls = {},
				vue_ls = {
					commentstring = "<!-- -->",
				},
        intelephense = {},
				-- rust_analyzer = {},
				-- ... etc. See `:help lspconfig-all` for a list of all the pre-configured LSPs
				--
				-- Some languages (like typescript) have entire language plugins that can be useful:
				--    https://github.com/pmizio/typescript-tools.nvim
				--
				-- But for many setups, the LSP (`ts_ls`) will work just fine
				-- ts_ls = { },

				lua_ls = {
					-- cmd = {...},
					-- filetypes = { ...},
					-- capabilities = {},
					-- settings = {
					--   Lua = {
					--     completion = {
					--       callSnippet = 'Replace',
					--     },
					--     -- You can toggle below to ignore Lua_LS's noisy `missing-fields` warnings
					--     -- diagnostics = { disable = { 'missing-fields' } },
					--   },
					-- },
				},
			}

			-- Ensure the servers and tools above are installed
			--  To check the current status of installed tools and/or manually install
			--  other tools, you can run
			--    :Mason
			--
			--  You can press `g?` for help in this menu.
			require("mason").setup()

			-- You can add other tools here that you want Mason to install
			-- for you, so that they are available from within Neovim.
			local ensure_installed = vim.tbl_keys(servers or {})
			vim.list_extend(ensure_installed, {
				"stylua", -- Used to format Lua code
			})
			require("mason-tool-installer").setup({ ensure_installed = ensure_installed })

			require("mason-lspconfig").setup({
				lazy = false,
				handlers = {
					function(server_name)
						local server = servers[server_name] or {}
						-- This handles overriding only values explicitly passed
						-- by the server configuration above. Useful when disabling
						-- certain features of an LSP (for example, turning off formatting for ts_ls)
						server.capabilities = vim.tbl_deep_extend("force", {}, capabilities, server.capabilities or {})
						require("lspconfig")[server_name].setup(server)
					end,
					["lua_ls"] = function()
						require("lspconfig").lua_ls.setup({
							settings = {
								Lua = {
									diagnostics = { globals = { "vim" } },
									hint = { enable = true },
								},
							},
						})
					end,
					["emmet_language_server"] = function()
						require("lspconfig").emmet_language_server.setup({
							cmd = { "emmet_language_server", "--stdio" },
							filetypes = {
								"html",
								"blade",
								"blade.php",
								"php",
							},
							init_options = {
								includeLanguages = {
									"blade",
									"blade.php",
									"php",
								},
							},
						})
					end,
					["vtsls"] = function()
						require("lspconfig.configs").vtsls = require("vtsls").lspconfig
						require("lspconfig").vtsls.setup({
							cmd = { "vtsls", "--stdio" },
							filetypes = {
								"javascript",
								"javascriptreact",
								"typescript",
								"typescriptreact",
							},
							settings = {
								typescript = {
									inlayHints = {
										includeInlayParameterNameHints = "all", -- 'none' | 'literals' | 'all'
										includeInlayParameterNameHintsWhenArgumentMatchesName = true,
										includeInlayVariableTypeHints = true,
										includeInlayFunctionParameterTypeHints = true,
										includeInlayVariableTypeHintsWhenTypeMatchesName = true,
										includeInlayPropertyDeclarationTypeHints = true,
										includeInlayFunctionLikeReturnTypeHints = true,
										includeInlayEnumMemberValueHints = true,
									},
								},
								javascript = {
									inlayHints = {
										includeInlayParameterNameHints = "all", -- 'none' | 'literals' | 'all'
										includeInlayParameterNameHintsWhenArgumentMatchesName = true,
										includeInlayVariableTypeHints = true,

										includeInlayFunctionParameterTypeHints = true,
										includeInlayVariableTypeHintsWhenTypeMatchesName = true,
										includeInlayPropertyDeclarationTypeHints = true,
										includeInlayFunctionLikeReturnTypeHints = true,
										includeInlayEnumMemberValueHints = true,
									},
								},
							},
						})
					end,
					-- ["ts_ls"] = function()
					-- 	require("lspconfig").ts_ls.setup({
					-- 		filetypes = {
					-- 			"javascript",
					-- 			"javascriptreact",
					-- 			"typescript",
					-- 			"typescriptreact",
					-- 		},
					-- 		-- handlers = {
					-- 		--     ["textDocument/publishDiagnostics"] = function(
					-- 		--         _,
					-- 		--         result,
					-- 		--         ctx,
					-- 		--         config
					-- 		--     )
					-- 		--         if result.diagnostics == nil then
					-- 		--             return
					-- 		--         end
					--
					-- 		--         -- ignore some tsserver diagnostics
					-- 		--         local idx = 1
					-- 		--         while idx <= #result.diagnostics do
					-- 		--             local entry = result.diagnostics[idx]
					--
					-- 		--             local formatter = require('format-ts-errors')[entry.code]
					-- 		--             entry.message = formatter and formatter(entry.message) or entry.message
					--
					-- 		--             -- codes: https://github.com/microsoft/TypeScript/blob/main/src/compiler/diagnosticMessages.json
					-- 		--             if entry.code == 80001 then
					-- 		--                 -- { message = "File is a CommonJS module; it may be converted to an ES module.", }
					-- 		--                 table.remove(result.diagnostics, idx)
					-- 		--             else
					-- 		--                 idx = idx + 1
					-- 		--             end
					-- 		--         end
					--
					-- 		--         vim.lsp.diagnostic.on_publish_diagnostics(
					-- 		--             _,
					-- 		--             result,
					-- 		--             ctx,
					-- 		--             config
					-- 		--         )
					-- 		--     end,
					-- 		-- },
					-- 		settings = {
					-- 			typescript = {
					-- 				inlayHints = {
					-- 					includeInlayParameterNameHints = "all", -- 'none' | 'literals' | 'all'
					-- 					includeInlayParameterNameHintsWhenArgumentMatchesName = true,
					-- 					includeInlayVariableTypeHints = true,
					-- 					includeInlayFunctionParameterTypeHints = true,
					-- 					includeInlayVariableTypeHintsWhenTypeMatchesName = true,
					-- 					includeInlayPropertyDeclarationTypeHints = true,
					-- 					includeInlayFunctionLikeReturnTypeHints = true,
					-- 					includeInlayEnumMemberValueHints = true,
					-- 				},
					-- 			},
					-- 			javascript = {
					-- 				inlayHints = {
					-- 					includeInlayParameterNameHints = "all", -- 'none' | 'literals' | 'all'
					-- 					includeInlayParameterNameHintsWhenArgumentMatchesName = true,
					-- 					includeInlayVariableTypeHints = true,
					--
					-- 					includeInlayFunctionParameterTypeHints = true,
					-- 					includeInlayVariableTypeHintsWhenTypeMatchesName = true,
					-- 					includeInlayPropertyDeclarationTypeHints = true,
					-- 					includeInlayFunctionLikeReturnTypeHints = true,
					-- 					includeInlayEnumMemberValueHints = true,
					-- 				},
					-- 			},
					-- 		},
					-- 	})
					-- end,
				},
			})
		end,
	},
}
-- vim: ts=2 sts=2 sw=2 et
