-- return {
--   dir = "/Users/carlos/Documents/SSD_Documents/projects/intellij.nvim",
--   dependencies = {
--     "mfussenegger/nvim-jdtls",      -- Java Language Server Protocol
--     "mfussenegger/nvim-dap",        -- Debug Adapter Protocol
--     "rcarriga/nvim-dap-ui",         -- DAP UI components
--     "akinsho/toggleterm.nvim",      -- Terminal integration
--     "nvim-telescope/telescope.nvim", -- For command palette search
--   },
--   config = function()
--     require("intellij").setup({
--       -- Theme configuration
--       theme = "inherit", -- or "light", "dark"
--       
--       -- Enable verbose logging for debugging
--       verbose_logging = false,
--       
--       -- Automatically toggle auto-open main file on start
--       auto_open_main_on_start = true,
--       
--       -- Custom actions for your workflow
--       custom_actions = {
--         {
--           name = "Open Project in IntelliJ IDEA",
--           action = function()
--             vim.fn.system("idea .")
--             vim.notify("Opening project in IntelliJ IDEA...")
--           end
--         },
--         {
--           name = "Open in VS Code",
--           action = function()
--             vim.fn.system("code .")
--             vim.notify("Opening project in VS Code...")
--           end
--         },
--         {
--           name = "Git Status",
--           action = function()
--             require("toggleterm").exec("git status", 1, 12, "float")
--           end
--         },
--         {
--           name = "Git Log",
--           action = function()
--             require("toggleterm").exec("git log --oneline -10", 1, 12, "float")
--           end
--         }
--       },
--       
--       -- Keymaps for quick access
--       keymaps = {
--         n = {
--           ["<leader>jp"] = function() require('intellij').show_palette() end,
--           ["<leader>jd"] = function() require('intellij').show_startup_diagnostics() end,
--           ["<leader>jr"] = function() require('intellij').reload() end,
--           ["<leader>jv"] = function() require('intellij').toggle_verbose_logging() end,
--         },
--         v = {
--           ["<leader>jt"] = function()
--             local start_line = vim.fn.line("'<")
--             local end_line = vim.fn.line("'>")
--             require("toggleterm").exec("mvn test -Dtest=*#" .. start_line .. "_" .. end_line, 1, 12, "float")
--           end
--         }
--       },
--       
--       -- Project-specific commands based on project type
--       project_commands = function(project_type)
--         local commands = {}
--         
--         if project_type == "spring-boot" then
--           table.insert(commands, {
--             name = "Spring Boot DevTools",
--             action = function()
--               require("toggleterm").exec("mvn spring-boot:run -Dspring-boot.run.profiles=dev", 1, 12, "float")
--             end
--           })
--           table.insert(commands, {
--             name = "Spring Boot Actuator Health",
--             action = function()
--               require("toggleterm").exec("curl -s http://localhost:8080/actuator/health | jq", 1, 12, "float")
--             end
--           })
--         end
--         
--         if project_type == "maven" then
--           table.insert(commands, {
--             name = "Maven Dependency Tree",
--             action = function()
--               require("toggleterm").exec("mvn dependency:tree", 1, 12, "float")
--             end
--           })
--           table.insert(commands, {
--             name = "Maven Clean Install",
--             action = function()
--               require("toggleterm").exec("mvn clean install", 1, 12, "float")
--             end
--           })
--         end
--         
--         if project_type == "gradle" then
--           table.insert(commands, {
--             name = "Gradle Dependencies",
--             action = function()
--               require("toggleterm").exec("./gradlew dependencies", 1, 12, "float")
--             end
--           })
--           table.insert(commands, {
--             name = "Gradle Clean Build",
--             action = function()
--               require("toggleterm").exec("./gradlew clean build", 1, 12, "float")
--             end
--           })
--         end
--         
--         return commands
--       end
--     })
--     
--     -- Register hooks for additional functionality
--     require("intellij").register_hook("actions", function(project_type)
--       local hooks = {}
--       
--       -- Add recent files action
--       table.insert(hooks, {
--         name = "Recent Java Files",
--         action = function()
--           local recent_files = require("intellij").get_recent_java_files()
--           if #recent_files > 0 then
--             vim.ui.select(recent_files, { prompt = "Recent Java Files:" }, function(choice)
--               if choice then
--                 local ok, _ = pcall(vim.cmd, "edit " .. choice)
--                 if not ok then
--                   vim.notify("Could not open file: " .. choice, vim.log.levels.WARN, { title = "intellij.nvim" })
--                 end
--               end
--             end)
--           else
--             vim.notify("No recent Java files found")
--           end
--         end
--       })
--       
--       return hooks
--     end)
--     
--     -- AUTOMATIC JAVA PROJECT DETECTION AND STARTUP
--     local function find_main_java_files()
--       local actions = require("intellij.actions")
--       local configs = actions.get_run_configs()
--       return configs and configs.mains or {}
--     end
--     
--     local function is_main_file_open()
--       local current_file = vim.api.nvim_buf_get_name(0)
--       local main_files = find_main_java_files()
--       
--       for _, main_file in ipairs(main_files) do
--         if current_file:match(main_file:gsub("%.", "/") .. "%.java$") then
--           return true
--         end
--       end
--       return false
--     end
--     
--     local function open_first_main_file()
--       local main_files = find_main_java_files()
--       
--       if #main_files > 0 then
--         -- Try to find the main file in the project
--         local project_root = vim.loop.cwd()
--         local found_file = nil
--         
--         -- Debug: show what we're looking for
--         vim.notify("Looking for main files: " .. table.concat(main_files, ", "), vim.log.levels.INFO, { title = "intellij.nvim" })
--         
--         for _, main_class in ipairs(main_files) do
--           local file_path
--           if main_class:match("%.java$") then
--             file_path = main_class:gsub("^%./", "")
--           else
--             file_path = main_class:gsub("%.", "/") .. ".java"
--           end
--           
--           local possible_paths = {
--             project_root .. "/" .. file_path,
--             project_root .. "/src/main/java/" .. file_path,
--             project_root .. "/src/java/" .. file_path,
--             project_root .. "/src/" .. file_path,
--             project_root .. "/app/src/main/java/" .. file_path,
--             project_root .. "/main/java/" .. file_path,
--           }
--           
--           for _, full_path in ipairs(possible_paths) do
--             if vim.fn.filereadable(full_path) == 1 then
--               found_file = full_path
--               vim.notify("Found main file at: " .. full_path, vim.log.levels.INFO, { title = "intellij.nvim" })
--               break
--             end
--           end
--           
--           if found_file then
--             break
--           end
--         end
--         
--         if found_file then
--           local ok, _ = pcall(vim.cmd, "edit " .. found_file)
--           if ok then
--             vim.notify("Opened main file: " .. found_file, vim.log.levels.INFO, { title = "intellij.nvim" })
--           else
--             vim.notify("Could not open main file: " .. found_file, vim.log.levels.WARN, { title = "intellij.nvim" })
--           end
--           return true
--         else
--           -- Use telescope for better selection if available
--           local function select_with_telescope(items, prompt, cb)
--             local ok, telescope = pcall(require, 'telescope.builtin')
--             if ok then
--               telescope.find_files({
--                 prompt_title = prompt,
--                 find_command = { 'echo', table.concat(items, '\n') },
--                 attach_mappings = function(_, map)
--                   require('telescope.actions').select_default:replace(function()
--                     local entry = require('telescope.actions.state').get_selected_entry()
--                     cb(entry.value)
--                     require('telescope.actions').close(_)
--                   end)
--                   return true
--                 end,
--               })
--             else
--               vim.ui.select(items, { prompt = prompt }, cb)
--             end
--           end
--           
--           vim.notify("Could not automatically find main files. Showing selection dialog.", vim.log.levels.WARN, { title = "intellij.nvim" })
--           select_with_telescope(main_files, "Select main class to open:", function(choice)
--             if choice then
--               local file_path
--               if choice:match("%.java$") then
--                 file_path = choice:gsub("^%./", "")
--               else
--                 file_path = choice:gsub("%.", "/") .. ".java"
--               end
--               
--               local possible_paths = {
--                 project_root .. "/" .. file_path,
--                 project_root .. "/src/main/java/" .. file_path,
--                 project_root .. "/src/java/" .. file_path,
--                 project_root .. "/src/" .. file_path,
--                 project_root .. "/app/src/main/java/" .. file_path,
--                 project_root .. "/main/java/" .. file_path,
--               }
--               
--               local found = false
--               for _, full_path in ipairs(possible_paths) do
--                 if vim.fn.filereadable(full_path) == 1 then
--                   local ok, _ = pcall(vim.cmd, "edit " .. full_path)
--                   if ok then
--                     vim.notify("Opened main file: " .. full_path, vim.log.levels.INFO, { title = "intellij.nvim" })
--                   else
--                     vim.notify("Could not open main file: " .. full_path, vim.log.levels.WARN, { title = "intellij.nvim" })
--                   end
--                   found = true
--                   break
--                 end
--               end
--               
--               if not found then
--                 vim.notify("Could not find main file for: " .. choice .. "\nTried paths:\n" .. table.concat(possible_paths, "\n"), vim.log.levels.WARN, { title = "intellij.nvim" })
--               end
--             end
--           end)
--           return true
--         end
--       else
--         vim.notify("No main files found in project", vim.log.levels.WARN, { title = "intellij.nvim" })
--       end
--       return false
--     end
--     
--     local function detect_and_start_java_project()
--       -- Prevent duplicate detection
--       if vim.b.java_project_detected then
--         return true
--       end
--       
--       local actions = require("intellij.actions")
--       local project_type = actions.detect_project_type()
--       
--       if project_type then
--         -- Store project info in buffer variables
--         vim.b.java_project_type = project_type
--         vim.b.java_project_detected = true
--         
--         -- Get JDK and environment info
--         local jdk_info = actions.get_jdk_info()
--         local env_info = actions.get_env_info()
--         
--         -- Show project detection notification (only once)
--         local jdk_version = jdk_info and jdk_info.jdk_version or "unknown"
--         vim.notify(
--           string.format("Java project detected: %s (JDK: %s)", project_type, jdk_version),
--           vim.log.levels.INFO,
--           { title = "intellij.nvim", timeout = 3000 }
--         )
--         
--         -- Auto-start Java LSP if available (only if not already started)
--         if pcall(require, 'jdtls') and not vim.lsp.get_active_clients({ name = 'jdtls' })[1] then
--           vim.defer_fn(function()
--             -- Try to start LSP safely with error handling
--             local ok, result = pcall(vim.cmd, "LspStart jdtls")
--             if ok then
--               vim.notify("Java LSP started", vim.log.levels.INFO, { title = "intellij.nvim" })
--               
--               -- Add error handler for LSP semantic tokens issues
--               vim.api.nvim_create_autocmd("LspAttach", {
--                 callback = function(args)
--                   local client = vim.lsp.get_client_by_id(args.data.client_id)
--                   if client and client.name == "jdtls" then
--                     -- Disable semantic tokens if they cause issues
--                     client.server_capabilities.semanticTokensProvider = nil
--                   end
--                 end,
--               })
--             else
--               vim.notify("Java LSP could not be started automatically", vim.log.levels.WARN, { title = "intellij.nvim" })
--             end
--           end, 1000)
--         end
--         
--         -- Auto-compile project on detection (optional)
--         if vim.g.auto_compile_java_projects then
--           vim.defer_fn(function()
--             if project_type == "maven" then
--               require("toggleterm").exec("mvn compile", 1, 12, "float")
--             elseif project_type == "gradle" then
--               require("toggleterm").exec("./gradlew compileJava", 1, 12, "float")
--             end
--           end, 2000)
--         end
--         
--         -- Auto-open main file if not already open
--         if vim.g.auto_open_main_file and not is_main_file_open() then
--           vim.defer_fn(function()
--             open_first_main_file()
--           end, 1500)
--         end
--         
--         return true
--       end
--       return false
--     end
--     
--     -- Set up autocommands for automatic detection (with debouncing)
--     local detection_timer = nil
--     
--     local function debounced_detection()
--       if detection_timer then
--         vim.loop.timer_stop(detection_timer)
--       end
--       detection_timer = vim.defer_fn(detect_and_start_java_project, 100)
--     end
--     
--     vim.api.nvim_create_autocmd("FileType", {
--       pattern = { "java" },
--       callback = function()
--         -- Auto-detect project type when opening Java files
--         debounced_detection()
--       end
--     })
--     
--     -- Auto-detect when entering directories with Java project files
--     vim.api.nvim_create_autocmd("DirChanged", {
--       pattern = "*",
--       callback = function()
--         -- Check if we're in a Java project directory
--         if vim.fn.filereadable("pom.xml") == 1 or 
--            vim.fn.filereadable("build.gradle") == 1 or 
--            vim.fn.filereadable("build.gradle.kts") == 1 then
--           debounced_detection()
--         end
--       end
--     })
--     
--     -- Auto-detect when opening files in Java project directories
--     vim.api.nvim_create_autocmd("BufRead", {
--       pattern = "*",
--       callback = function()
--         local cwd = vim.loop.cwd()
--         if cwd and (vim.fn.filereadable(cwd .. "/pom.xml") == 1 or 
--                    vim.fn.filereadable(cwd .. "/build.gradle") == 1 or 
--                    vim.fn.filereadable(cwd .. "/build.gradle.kts") == 1) then
--           debounced_detection()
--         end
--       end
--     })
--     
--     -- Auto-detect when VimEnter (when Neovim starts)
--     vim.api.nvim_create_autocmd("VimEnter", {
--       pattern = "*",
--       callback = function()
--         -- Check if we started in a Java project directory
--         local cwd = vim.loop.cwd()
--         if cwd and (vim.fn.filereadable(cwd .. "/pom.xml") == 1 or 
--                    vim.fn.filereadable(cwd .. "/build.gradle") == 1 or 
--                    vim.fn.filereadable(cwd .. "/build.gradle.kts") == 1) then
--           vim.defer_fn(detect_and_start_java_project, 500)
--         end
--       end
--     })
--     
--     -- Global variable to control auto-compilation
--     vim.g.auto_compile_java_projects = true
--     
--     -- Global variable to control auto-opening main files
--     vim.g.auto_open_main_file = true
--     
--     -- Add command to toggle auto-compilation
--     vim.api.nvim_create_user_command("ToggleJavaAutoCompile", function()
--       vim.g.auto_compile_java_projects = not vim.g.auto_compile_java_projects
--       vim.notify(
--         "Java auto-compilation " .. (vim.g.auto_compile_java_projects and "enabled" or "disabled"),
--         vim.log.levels.INFO,
--         { title = "intellij.nvim" }
--       )
--     end, {})
--     
--     -- Add command to clean up cache and temporary files
--     vim.api.nvim_create_user_command("IntelliJCleanup", function()
--       require("intellij").cleanup()
--     end, {})
--     
--     -- Add command to toggle auto-opening main files
--     vim.api.nvim_create_user_command("ToggleJavaAutoOpenMain", function()
--       vim.g.auto_open_main_file = not vim.g.auto_open_main_file
--       vim.notify(
--         "Java auto-open main file " .. (vim.g.auto_open_main_file and "enabled" or "disabled"),
--         vim.log.levels.INFO,
--         { title = "intellij.nvim" }
--       )
--     end, {})
--     
--     -- Add command to manually open main file
--     vim.api.nvim_create_user_command("OpenJavaMainFile", function()
--       if open_first_main_file() then
--         vim.notify("Main file opened", vim.log.levels.INFO, { title = "intellij.nvim" })
--       else
--         vim.notify("No main file found in current project", vim.log.levels.WARN, { title = "intellij.nvim" })
--       end
--     end, {})
--     
--     -- Add command to debug file search
--     vim.api.nvim_create_user_command("DebugJavaFileSearch", function()
--       local actions = require("intellij.actions")
--       local configs = actions.get_run_configs()
--       
--       vim.notify("=== Java File Search Debug ===", vim.log.levels.INFO, { title = "intellij.nvim" })
--       vim.notify("Project root: " .. vim.loop.cwd(), vim.log.levels.INFO, { title = "intellij.nvim" })
--       
--       if configs and configs.mains then
--         vim.notify("Found main classes: " .. table.concat(configs.mains, ", "), vim.log.levels.INFO, { title = "intellij.nvim" })
--         
--         for _, main_class in ipairs(configs.mains) do
--           local file_path = main_class:gsub("%.", "/") .. ".java"
--           local project_root = vim.loop.cwd()
--           
--           local possible_paths = {
--             project_root .. "/src/main/java/" .. file_path,
--             project_root .. "/src/java/" .. file_path,
--             project_root .. "/src/" .. file_path,
--             project_root .. "/" .. file_path,
--             project_root .. "/app/src/main/java/" .. file_path,
--             project_root .. "/main/java/" .. file_path,
--           }
--           
--           vim.notify("Searching for: " .. main_class, vim.log.levels.INFO, { title = "intellij.nvim" })
--           for _, path in ipairs(possible_paths) do
--             local exists = vim.fn.filereadable(path) == 1
--             vim.notify("  " .. path .. " -> " .. (exists and "EXISTS" or "NOT FOUND"), vim.log.levels.INFO, { title = "intellij.nvim" })
--           end
--         end
--       else
--         vim.notify("No main classes found", vim.log.levels.WARN, { title = "intellij.nvim" })
--       end
--     end, {})
--     
--     -- Add command to manually detect Java project
--     vim.api.nvim_create_user_command("DetectJavaProject", function()
--       if detect_and_start_java_project() then
--         vim.notify("Java project detection completed", vim.log.levels.INFO, { title = "intellij.nvim" })
--       else
--         vim.notify("No Java project detected in current directory", vim.log.levels.WARN, { title = "intellij.nvim" })
--       end
--     end, {})
--
--     -- Check for config flag to auto-toggle main file opening
--     if type(require("intellij").opts) == "table" and require("intellij").opts.auto_open_main_on_start then
--       vim.g.auto_open_main_file = true
--     end
--   end
-- }