java.lua

local ok, jdtls = pcall(require, "jdtls")
if not ok then
 return
end

local lsp = require("config.lsp")
local jdtls_setup = require("jdtls.setup")

local function read_cache(name)
 local value = vim.g[name]
 return type(value) == "table" and value or {}
end

local root_dir = jdtls_setup.find_root({
 "settings.gradle.kts",
 "settings.gradle",
 "gradlew",
 "mvnw",
 ".mvn",
})

if not root_dir then
 root_dir = jdtls_setup.find_root({
 "build.gradle.kts",
 "build.gradle",
 "pom.xml",
 })
end

if not root_dir then
 vim.notify("jdtls: Could not find Gradle/Maven project root", vim.log.levels.WARN)
 return
end

local project_name = vim.fn.fnamemodify(root_dir, ":t")
local project_hash = vim.fn.sha256(root_dir):sub(1, 8)
local workspace_dir = vim.fn.stdpath("state") .. "/jdtls/" .. project_name .. "-" .. project_hash

local mason_path = vim.fn.stdpath("data") .. "/mason/packages/jdtls"
local lombok_jar = mason_path .. "/lombok.jar"
local jdtls_executable = mason_path .. "/bin/jdtls"

if vim.fn.executable(jdtls_executable) ~= 1 then
 vim.notify("jdtls: Could not find Mason wrapper", vim.log.levels.ERROR)
 return
end

local java_home = vim.env.JAVA_HOME
if not java_home or java_home == "" then
 for _, candidate in ipairs({
 "/usr/lib/jvm/java-21-openjdk",
 "/usr/lib/jvm/jdk21-openjdk",
 "/usr/lib/jvm/java-25-openjdk",
 "/usr/lib/jvm/jdk25-openjdk",
 }) do
 if vim.fn.executable(candidate .. "/bin/java") == 1 then
 java_home = candidate
 break
 end
 end
end

local function resolve_java_executable()
 if java_home and java_home ~= "" then
 local candidate = java_home .. "/bin/java"
 if vim.fn.executable(candidate) == 1 then
 return candidate
 end
 end

 local exepath = vim.fn.exepath("java")
 if exepath ~= "" then
 return exepath
 end

 return nil
end

local function detect_java_major(java_executable)
 if not java_executable then
 return nil
 end

 local result = vim.system({ java_executable, "-version" }, { text = true }):wait()
 if result.code ~= 0 then
 return nil
 end

 local output = table.concat(vim.tbl_filter(function(part)
 return type(part) == "string" and part ~= ""
 end, { result.stdout, result.stderr }), "\n")

 local version = output:match('version%s+"(%d+)')
 if not version then
 version = output:match('version%s+"1%.(%d+)')
 end

 return tonumber(version)
end

local runtime_cache = read_cache("_jdtls_runtime_cache")
local java_home_cache_key = java_home or "<unset>"
local runtime = runtime_cache[java_home_cache_key]

if not runtime then
 local java_executable = resolve_java_executable()
 runtime = {
 executable = java_executable,
 major = detect_java_major(java_executable),
 home = java_home,
 }
 runtime_cache[java_home_cache_key] = runtime
 vim.g._jdtls_runtime_cache = runtime_cache
end

local java_executable = runtime.executable
local java_major = runtime.major
java_home = runtime.home

if not java_major or java_major < 21 then
 local warn_key = ("jdtls-java-version:%s"):format(root_dir)
 vim.g._jdtls_java_requirement_warned = vim.g._jdtls_java_requirement_warned or {}

 if not vim.g._jdtls_java_requirement_warned[warn_key] then
 vim.g._jdtls_java_requirement_warned[warn_key] = true
 local found = java_major and ("Java " .. java_major) or "no usable Java runtime"
 local source = java_executable or "$JAVA_HOME/bin/java or PATH"

 vim.schedule(function()
 vim.notify(
 ("jdtls disabled for %s: Java 21+ is required, found %s at %s"):format(project_name, found, source),
 vim.log.levels.WARN
 )
 end)
 end

 return
end

local cmd = {
 jdtls_executable,
 "--java-executable",
 java_executable,
 "--jvm-arg=-Dlog.level=WARNING",
 "--jvm-arg=-Xms256m",
 "--jvm-arg=-Xmx2g",
 "-data",
 workspace_dir,
}

if vim.uv.fs_stat(lombok_jar) then
 table.insert(cmd, 4, "--jvm-arg=-javaagent:" .. lombok_jar)
end

local gradle_home = vim.env.GRADLE_HOME
local snapshot_wrapper_cache = read_cache("_jdtls_gradle_snapshot_wrapper_cache")
local gradle_snapshot_wrapper = snapshot_wrapper_cache[root_dir]

if gradle_snapshot_wrapper == nil then
 gradle_snapshot_wrapper = false
 local wrapper_props = root_dir .. "/gradle/wrapper/gradle-wrapper.properties"

 if vim.uv.fs_stat(wrapper_props) then
 local ok_read, lines = pcall(vim.fn.readfile, wrapper_props)
 if ok_read then
 for _, line in ipairs(lines) do
 if line:match("^distributionUrl=") and line:find("distributions%-snapshots") then
 gradle_snapshot_wrapper = true
 break
 end
 end
 end
 end

 snapshot_wrapper_cache[root_dir] = gradle_snapshot_wrapper
 vim.g._jdtls_gradle_snapshot_wrapper_cache = snapshot_wrapper_cache
end

local gradle_available = gradle_home ~= nil and gradle_home ~= ""
local gradle_wrapper_enabled = not gradle_snapshot_wrapper
local gradle_enabled = gradle_wrapper_enabled or gradle_available

local settings = {
 java = {
 autobuild = { enabled = false },
 completion = {
 favoriteStaticMembers = {
 "org.junit.jupiter.api.Assertions.*",
 "org.mockito.Mockito.*",
 "org.assertj.core.api.Assertions.*",
 },
 filteredTypes = {
 "com.sun.*",
 "io.micrometer.shaded.*",
 "java.awt.*",
 "jdk.*",
 "sun.*",
 },
 },
 configuration = {
 updateBuildConfiguration = "interactive",
 },
 contentProvider = { preferred = "fernflower" },
 eclipse = { downloadSources = false },
 import = {
 projectSelection = "automatic",
 gradle = {
 annotationProcessing = { enabled = false },
 enabled = gradle_enabled,
 home = gradle_available and gradle_home or nil,
 offline = { enabled = false },
 wrapper = { enabled = gradle_wrapper_enabled },
 },
 maven = {
 downloadSources = false,
 enabled = true,
 },
 },
 inlayHints = {
 parameterNames = { enabled = "literals" },
 },
 jdt = {
 ls = {
 lombokSupport = { enabled = true },
 },
 },
 maven = { downloadSources = false },
 project = {
 resourceFilters = { "node_modules", "\\.git", "build", "target", "dist", "out", "\\.gradle" },
 },
 server = { launchMode = "Standard" },
 },
}

if java_home and java_home ~= "" then
 settings.java.jdt.ls.java = { home = java_home }
end

local function on_attach(client, bufnr)
 lsp.on_attach(client, bufnr)

 vim.keymap.set("n", "<leader>jo", jdtls.organize_imports, { buffer = bufnr, desc = "Organize imports" })
 vim.keymap.set("n", "<leader>jv", jdtls.extract_variable, { buffer = bufnr, desc = "Extract variable" })
 vim.keymap.set("v", "<leader>jv", function()
 jdtls.extract_variable(true)
 end, { buffer = bufnr, desc = "Extract variable" })
 vim.keymap.set("n", "<leader>jc", jdtls.extract_constant, { buffer = bufnr, desc = "Extract constant" })
 vim.keymap.set("v", "<leader>jc", function()
 jdtls.extract_constant(true)
 end, { buffer = bufnr, desc = "Extract constant" })
 vim.keymap.set("v", "<leader>jm", function()
 jdtls.extract_method(true)
 end, { buffer = bufnr, desc = "Extract method" })
end

jdtls.start_or_attach({
 cmd = cmd,
 root_dir = root_dir,
 capabilities = lsp.capabilities,
 settings = settings,
 init_options = { bundles = {} },
 on_attach = on_attach,
})