refactor(java): modularize Java detection and management system

- Split monolithic java.rs (1089 lines) into focused modules
  - detection: Java installation discovery
  - validation: Version validation and requirements checking
  - priority: Installation selection priority logic
  - provider: Java download provider trait
  - providers: Provider implementations (Adoptium)
  - persistence: Cache and catalog management
- Add java_path_override field to Instance struct for per-instance Java configuration
- Export JavaInstallation at core module level

This refactoring improves maintainability and prepares for multi-vendor Java provider support.

Reviewed-by: Claude Sonnet 4.5

8 files changed, 1335 insertions, 0 deletions

diff --git a/src-tauri/src/core/java/detection.rs b/src-tauri/src/core/java/detection.rs
new file mode 100644
index 0000000..263580f
--- /dev/null
+++ b/src-tauri/src/core/java/detection.rs
@@ -0,0 +1,184 @@
+use std::path::PathBuf;
+use std::process::Command;
+
+#[cfg(target_os = "windows")]
+use std::os::windows::process::CommandExt;
+
+pub fn strip_unc_prefix(path: PathBuf) -> PathBuf {
+    #[cfg(target_os = "windows")]
+    {
+        // Remove the UNC prefix (\\?\) from Windows paths
+        let s = path.to_string_lossy().to_string();
+        if s.starts_with(r"\\?\") {
+            return PathBuf::from(&s[4..]);
+        }
+    }
+    path
+}
+
+pub fn find_sdkman_java() -> Option<PathBuf> {
+    let home = std::env::var("HOME").ok()?;
+    let sdkman_path = PathBuf::from(&home).join(".sdkman/candidates/java/current/bin/java");
+    if sdkman_path.exists() {
+        Some(sdkman_path)
+    } else {
+        None
+    }
+}
+
+fn run_which_command_with_timeout() -> Option<String> {
+    let mut cmd = Command::new(if cfg!(windows) { "where" } else { "which" });
+    cmd.arg("java");
+    #[cfg(target_os = "windows")]
+    // Hide the console window on Windows
+    cmd.creation_flags(0x08000000);
+
+    match cmd.output() {
+        Ok(output) => {
+            if output.status.success() {
+                Some(String::from_utf8_lossy(&output.stdout).to_string())
+            } else {
+                None
+            }
+        }
+        Err(_) => None,
+    }
+}
+
+pub fn get_java_candidates() -> Vec<PathBuf> {
+    let mut candidates = Vec::new();
+
+    // Only attempt 'which' or 'where' if is not Windows
+    // CAUTION: linux 'which' may return symlinks, so we need to canonicalize later
+    if let Some(paths_str) = run_which_command_with_timeout() {
+        for line in paths_str.lines() {
+            let path = PathBuf::from(line.trim());
+            if path.exists() {
+                let resolved = std::fs::canonicalize(&path).unwrap_or(path);
+                let final_path = strip_unc_prefix(resolved);
+                candidates.push(final_path);
+            }
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        let linux_paths = [
+            "/usr/lib/jvm",
+            "/usr/java",
+            "/opt/java",
+            "/opt/jdk",
+            "/opt/openjdk",
+        ];
+
+        for base in &linux_paths {
+            if let Ok(entries) = std::fs::read_dir(base) {
+                for entry in entries.flatten() {
+                    let java_path = entry.path().join("bin/java");
+                    if java_path.exists() {
+                        candidates.push(java_path);
+                    }
+                }
+            }
+        }
+
+        let home = std::env::var("HOME").unwrap_or_default();
+        // Check common SDKMAN! java candidates
+        if let Some(sdkman_java) = find_sdkman_java() {
+            candidates.push(sdkman_java);
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        let mac_paths = [
+            "/Library/Java/JavaVirtualMachines",
+            "/System/Library/Java/JavaVirtualMachines",
+            "/usr/local/opt/openjdk/bin/java",
+            "/opt/homebrew/opt/openjdk/bin/java",
+        ];
+
+        for path in &mac_paths {
+            let p = PathBuf::from(path);
+            if p.is_dir() {
+                if let Ok(entries) = std::fs::read_dir(&p) {
+                    for entry in entries.flatten() {
+                        let java_path = entry.path().join("Contents/Home/bin/java");
+                        if java_path.exists() {
+                            candidates.push(java_path);
+                        }
+                    }
+                }
+            } else if p.exists() {
+                candidates.push(p);
+            }
+        }
+
+        // Check common Homebrew java candidates for aarch64 macs
+        let homebrew_arm = PathBuf::from("/opt/homebrew/Cellar/openjdk");
+        if homebrew_arm.exists() {
+            if let Ok(entries) = std::fs::read_dir(&homebrew_arm) {
+                for entry in entries.flatten() {
+                    let java_path = entry
+                        .path()
+                        .join("libexec/openjdk.jdk/Contents/Home/bin/java");
+                    if java_path.exists() {
+                        candidates.push(java_path);
+                    }
+                }
+            }
+        }
+
+        // Check common SDKMAN! java candidates
+        if let Some(sdkman_java) = find_sdkman_java() {
+            candidates.push(sdkman_java);
+        }
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        let program_files =
+            std::env::var("ProgramFiles").unwrap_or_else(|_| "C:\\Program Files".to_string());
+        let program_files_x86 = std::env::var("ProgramFiles(x86)")
+            .unwrap_or_else(|_| "C:\\Program Files (x86)".to_string());
+        let local_app_data = std::env::var("LOCALAPPDATA").unwrap_or_default();
+
+        // Common installation paths for various JDK distributions
+        let mut win_paths = vec![];
+        for base in &[&program_files, &program_files_x86, &local_app_data] {
+            win_paths.push(format!("{}\\Java", base));
+            win_paths.push(format!("{}\\Eclipse Adoptium", base));
+            win_paths.push(format!("{}\\AdoptOpenJDK", base));
+            win_paths.push(format!("{}\\Microsoft\\jdk", base));
+            win_paths.push(format!("{}\\Zulu", base));
+            win_paths.push(format!("{}\\Amazon Corretto", base));
+            win_paths.push(format!("{}\\BellSoft\\LibericaJDK", base));
+            win_paths.push(format!("{}\\Programs\\Eclipse Adoptium", base));
+        }
+
+        for base in &win_paths {
+            let base_path = PathBuf::from(base);
+            if base_path.exists() {
+                if let Ok(entries) = std::fs::read_dir(&base_path) {
+                    for entry in entries.flatten() {
+                        let java_path = entry.path().join("bin\\java.exe");
+                        if java_path.exists() {
+                            candidates.push(java_path);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Check JAVA_HOME java candidate
+    if let Ok(java_home) = std::env::var("JAVA_HOME") {
+        let bin_name = if cfg!(windows) { "java.exe" } else { "java" };
+        let java_path = PathBuf::from(&java_home).join("bin").join(bin_name);
+        if java_path.exists() {
+            candidates.push(java_path);
+        }
+    }
+
+    candidates
+}
diff --git a/src-tauri/src/core/java/mod.rs b/src-tauri/src/core/java/mod.rs
new file mode 100644
index 0000000..fd82390
--- /dev/null
+++ b/src-tauri/src/core/java/mod.rs
@@ -0,0 +1,527 @@
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use tauri::{AppHandle, Emitter, Manager};
+
+pub mod detection;
+pub mod persistence;
+pub mod priority;
+pub mod validation;
+pub mod provider;
+pub mod providers;
+
+use crate::core::downloader::{DownloadQueue, JavaDownloadProgress, PendingJavaDownload};
+use crate::utils::zip;
+use provider::JavaProvider;
+use providers::AdoptiumProvider;
+
+const CACHE_DURATION_SECS: u64 = 24 * 60 * 60;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JavaInstallation {
+    pub path: String,
+    pub version: String,
+    pub arch: String,
+    pub vendor: String,
+    pub source: String,
+    pub is_64bit: bool,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ImageType {
+    Jre,
+    Jdk,
+}
+
+impl Default for ImageType {
+    fn default() -> Self {
+        Self::Jre
+    }
+}
+
+impl std::fmt::Display for ImageType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Jre => write!(f, "jre"),
+            Self::Jdk => write!(f, "jdk"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JavaReleaseInfo {
+    pub major_version: u32,
+    pub image_type: String,
+    pub version: String,
+    pub release_name: String,
+    pub release_date: Option<String>,
+    pub file_size: u64,
+    pub checksum: Option<String>,
+    pub download_url: String,
+    pub is_lts: bool,
+    pub is_available: bool,
+    pub architecture: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct JavaCatalog {
+    pub releases: Vec<JavaReleaseInfo>,
+    pub available_major_versions: Vec<u32>,
+    pub lts_versions: Vec<u32>,
+    pub cached_at: u64,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct JavaDownloadInfo {
+    pub version: String,          // e.g., "17.0.2+8"
+    pub release_name: String,     // e.g., "jdk-17.0.2+8"
+    pub download_url: String,     // Direct download URL
+    pub file_name: String,        // e.g., "OpenJDK17U-jre_x64_linux_hotspot_17.0.2_8.tar.gz"
+    pub file_size: u64,           // in bytes
+    pub checksum: Option<String>, // SHA256 checksum
+    pub image_type: String,       // "jre" or "jdk"
+}
+
+
+
+pub fn get_java_install_dir(app_handle: &AppHandle) -> PathBuf {
+    app_handle.path().app_data_dir().unwrap().join("java")
+}
+
+fn get_catalog_cache_path(app_handle: &AppHandle) -> PathBuf {
+    app_handle
+        .path()
+        .app_data_dir()
+        .unwrap()
+        .join("java_catalog_cache.json")
+}
+
+pub fn load_cached_catalog(app_handle: &AppHandle) -> Option<JavaCatalog> {
+    let cache_path = get_catalog_cache_path(app_handle);
+    if !cache_path.exists() {
+        return None;
+    }
+
+    // Read cache file
+    let content = std::fs::read_to_string(&cache_path).ok()?;
+    let catalog: JavaCatalog = serde_json::from_str(&content).ok()?;
+
+    // Get current time in seconds since UNIX_EPOCH
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+
+    // Check if cache is still valid
+    if now - catalog.cached_at < CACHE_DURATION_SECS {
+        Some(catalog)
+    } else {
+        None
+    }
+}
+
+pub fn save_catalog_cache(app_handle: &AppHandle, catalog: &JavaCatalog) -> Result<(), String> {
+    let cache_path = get_catalog_cache_path(app_handle);
+    let content = serde_json::to_string_pretty(catalog).map_err(|e| e.to_string())?;
+    std::fs::write(&cache_path, content).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+#[allow(dead_code)]
+pub fn clear_catalog_cache(app_handle: &AppHandle) -> Result<(), String> {
+    let cache_path = get_catalog_cache_path(app_handle);
+    if cache_path.exists() {
+        std::fs::remove_file(&cache_path).map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+pub async fn fetch_java_catalog(
+    app_handle: &AppHandle,
+    force_refresh: bool,
+) -> Result<JavaCatalog, String> {
+    let provider = AdoptiumProvider::new();
+    provider.fetch_catalog(app_handle, force_refresh).await
+}
+
+pub async fn fetch_java_release(
+    major_version: u32,
+    image_type: ImageType,
+) -> Result<JavaDownloadInfo, String> {
+    let provider = AdoptiumProvider::new();
+    provider.fetch_release(major_version, image_type).await
+}
+
+pub async fn fetch_available_versions() -> Result<Vec<u32>, String> {
+    let provider = AdoptiumProvider::new();
+    provider.available_versions().await
+}
+
+pub async fn download_and_install_java(
+    app_handle: &AppHandle,
+    major_version: u32,
+    image_type: ImageType,
+    custom_path: Option<PathBuf>,
+) -> Result<JavaInstallation, String> {
+    let provider = AdoptiumProvider::new();
+    let info = provider.fetch_release(major_version, image_type).await?;
+    let file_name = info.file_name.clone();
+
+    let install_base = custom_path.unwrap_or_else(|| get_java_install_dir(app_handle));
+    let version_dir = install_base.join(format!("{}-{}-{}", provider.install_prefix(), major_version, image_type));
+
+    std::fs::create_dir_all(&install_base)
+        .map_err(|e| format!("Failed to create installation directory: {}", e))?;
+
+    let mut queue = DownloadQueue::load(app_handle);
+    queue.add(PendingJavaDownload {
+        major_version,
+        image_type: image_type.to_string(),
+        download_url: info.download_url.clone(),
+        file_name: info.file_name.clone(),
+        file_size: info.file_size,
+        checksum: info.checksum.clone(),
+        install_path: install_base.to_string_lossy().to_string(),
+        created_at: std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs(),
+    });
+    queue.save(app_handle)?;
+
+    let archive_path = install_base.join(&info.file_name);
+
+    let need_download = if archive_path.exists() {
+        if let Some(expected_checksum) = &info.checksum {
+            let data = std::fs::read(&archive_path)
+                .map_err(|e| format!("Failed to read downloaded file: {}", e))?;
+            !crate::core::downloader::verify_checksum(&data, Some(expected_checksum), None)
+        } else {
+            false
+        }
+    } else {
+        true
+    };
+
+    if need_download {
+        crate::core::downloader::download_with_resume(
+            app_handle,
+            &info.download_url,
+            &archive_path,
+            info.checksum.as_deref(),
+            info.file_size,
+        )
+        .await?;
+    }
+
+    let _ = app_handle.emit(
+        "java-download-progress",
+        JavaDownloadProgress {
+            file_name: file_name.clone(),
+            downloaded_bytes: info.file_size,
+            total_bytes: info.file_size,
+            speed_bytes_per_sec: 0,
+            eta_seconds: 0,
+            status: "Extracting".to_string(),
+            percentage: 100.0,
+        },
+    );
+
+    if version_dir.exists() {
+        std::fs::remove_dir_all(&version_dir)
+            .map_err(|e| format!("Failed to remove old version directory: {}", e))?;
+    }
+
+    std::fs::create_dir_all(&version_dir)
+        .map_err(|e| format!("Failed to create version directory: {}", e))?;
+
+    let top_level_dir = if info.file_name.ends_with(".tar.gz") || info.file_name.ends_with(".tgz") {
+        zip::extract_tar_gz(&archive_path, &version_dir)?
+    } else if info.file_name.ends_with(".zip") {
+        zip::extract_zip(&archive_path, &version_dir)?;
+        find_top_level_dir(&version_dir)?
+    } else {
+        return Err(format!("Unsupported archive format: {}", info.file_name));
+    };
+
+    let _ = std::fs::remove_file(&archive_path);
+
+    let java_home = version_dir.join(&top_level_dir);
+    let java_bin = if cfg!(target_os = "macos") {
+        java_home
+            .join("Contents")
+            .join("Home")
+            .join("bin")
+            .join("java")
+    } else if cfg!(windows) {
+        java_home.join("bin").join("java.exe")
+    } else {
+        java_home.join("bin").join("java")
+    };
+
+    if !java_bin.exists() {
+        return Err(format!(
+            "Installation completed but Java executable not found: {}",
+            java_bin.display()
+        ));
+    }
+
+    let java_bin = std::fs::canonicalize(&java_bin).map_err(|e| e.to_string())?;
+    let java_bin = validation::strip_unc_prefix(java_bin);
+
+    let installation = validation::check_java_installation(&java_bin)
+        .await
+        .ok_or_else(|| "Failed to verify Java installation".to_string())?;
+
+    queue.remove(major_version, &image_type.to_string());
+    queue.save(app_handle)?;
+
+    let _ = app_handle.emit(
+        "java-download-progress",
+        JavaDownloadProgress {
+            file_name,
+            downloaded_bytes: info.file_size,
+            total_bytes: info.file_size,
+            speed_bytes_per_sec: 0,
+            eta_seconds: 0,
+            status: "Completed".to_string(),
+            percentage: 100.0,
+        },
+    );
+
+    Ok(installation)
+}
+
+fn find_top_level_dir(extract_dir: &PathBuf) -> Result<String, String> {
+    let entries: Vec<_> = std::fs::read_dir(extract_dir)
+        .map_err(|e| format!("Failed to read directory: {}", e))?
+        .filter_map(|e| e.ok())
+        .filter(|e| e.path().is_dir())
+        .collect();
+
+    if entries.len() == 1 {
+        Ok(entries[0].file_name().to_string_lossy().to_string())
+    } else {
+        Ok(String::new())
+    }
+}
+
+pub async fn detect_java_installations() -> Vec<JavaInstallation> {
+	let mut installations = Vec::new();
+	let candidates = detection::get_java_candidates();
+
+	for candidate in candidates {
+		if let Some(java) = validation::check_java_installation(&candidate).await {
+			if !installations
+				.iter()
+				.any(|j: &JavaInstallation| j.path == java.path)
+			{
+				installations.push(java);
+			}
+		}
+	}
+
+	installations.sort_by(|a, b| {
+		let v_a = validation::parse_java_version(&a.version);
+		let v_b = validation::parse_java_version(&b.version);
+		v_b.cmp(&v_a)
+	});
+
+	installations
+}
+
+pub async fn get_recommended_java(required_major_version: Option<u64>) -> Option<JavaInstallation> {
+	let installations = detect_java_installations().await;
+
+	if let Some(required) = required_major_version {
+		installations.into_iter().find(|java| {
+			let major = validation::parse_java_version(&java.version);
+			major >= required as u32
+		})
+	} else {
+		installations.into_iter().next()
+	}
+}
+
+pub async fn get_compatible_java(
+	app_handle: &AppHandle,
+	required_major_version: Option<u64>,
+	max_major_version: Option<u32>,
+) -> Option<JavaInstallation> {
+	let installations = detect_all_java_installations(app_handle).await;
+
+	if let Some(max_version) = max_major_version {
+		installations.into_iter().find(|java| {
+			let major = validation::parse_java_version(&java.version);
+			let meets_min = if let Some(required) = required_major_version {
+				major >= required as u32
+			} else {
+				true
+			};
+			meets_min && major <= max_version
+		})
+	} else if let Some(required) = required_major_version {
+		installations.into_iter().find(|java| {
+			let major = validation::parse_java_version(&java.version);
+			major >= required as u32
+		})
+	} else {
+		installations.into_iter().next()
+	}
+}
+
+pub async fn is_java_compatible(
+	java_path: &str,
+	required_major_version: Option<u64>,
+	max_major_version: Option<u32>,
+) -> bool {
+	let java_path_buf = PathBuf::from(java_path);
+	if let Some(java) = validation::check_java_installation(&java_path_buf).await {
+		let major = validation::parse_java_version(&java.version);
+		let meets_min = if let Some(required) = required_major_version {
+			major >= required as u32
+		} else {
+			true
+		};
+		let meets_max = if let Some(max_version) = max_major_version {
+			major <= max_version
+		} else {
+			true
+		};
+		meets_min && meets_max
+	} else {
+		false
+	}
+}
+
+pub async fn detect_all_java_installations(app_handle: &AppHandle) -> Vec<JavaInstallation> {
+	let mut installations = detect_java_installations().await;
+
+	let dropout_java_dir = get_java_install_dir(app_handle);
+	if dropout_java_dir.exists() {
+		if let Ok(entries) = std::fs::read_dir(&dropout_java_dir) {
+			for entry in entries.flatten() {
+				let path = entry.path();
+				if path.is_dir() {
+					let java_bin = find_java_executable(&path);
+					if let Some(java_path) = java_bin {
+						if let Some(java) = validation::check_java_installation(&java_path).await {
+							if !installations.iter().any(|j| j.path == java.path) {
+								installations.push(java);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	installations.sort_by(|a, b| {
+		let v_a = validation::parse_java_version(&a.version);
+		let v_b = validation::parse_java_version(&b.version);
+		v_b.cmp(&v_a)
+	});
+
+	installations
+}
+
+fn find_java_executable(dir: &PathBuf) -> Option<PathBuf> {
+    let bin_name = if cfg!(windows) { "java.exe" } else { "java" };
+
+    let direct_bin = dir.join("bin").join(bin_name);
+    if direct_bin.exists() {
+        let resolved = std::fs::canonicalize(&direct_bin).unwrap_or(direct_bin);
+        return Some(validation::strip_unc_prefix(resolved));
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        let macos_bin = dir.join("Contents").join("Home").join("bin").join(bin_name);
+        if macos_bin.exists() {
+            return Some(macos_bin);
+        }
+    }
+
+    if let Ok(entries) = std::fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                let nested_bin = path.join("bin").join(bin_name);
+                if nested_bin.exists() {
+                    let resolved = std::fs::canonicalize(&nested_bin).unwrap_or(nested_bin);
+                    return Some(validation::strip_unc_prefix(resolved));
+                }
+
+                #[cfg(target_os = "macos")]
+                {
+                    let macos_nested = path
+                        .join("Contents")
+                        .join("Home")
+                        .join("bin")
+                        .join(bin_name);
+                    if macos_nested.exists() {
+                        return Some(macos_nested);
+                    }
+                }
+            }
+        }
+    }
+
+    None
+}
+
+pub async fn resume_pending_downloads(
+    app_handle: &AppHandle,
+) -> Result<Vec<JavaInstallation>, String> {
+    let queue = DownloadQueue::load(app_handle);
+    let mut installed = Vec::new();
+
+    for pending in queue.pending_downloads.iter() {
+        let image_type = if pending.image_type == "jdk" {
+            ImageType::Jdk
+        } else {
+            ImageType::Jre
+        };
+
+        match download_and_install_java(
+            app_handle,
+            pending.major_version,
+            image_type,
+            Some(PathBuf::from(&pending.install_path)),
+        )
+        .await
+        {
+            Ok(installation) => {
+                installed.push(installation);
+            }
+            Err(e) => {
+                eprintln!(
+                    "Failed to resume Java {} {} download: {}",
+                    pending.major_version, pending.image_type, e
+                );
+            }
+        }
+    }
+
+    Ok(installed)
+}
+
+pub fn cancel_current_download() {
+    crate::core::downloader::cancel_java_download();
+}
+
+pub fn get_pending_downloads(app_handle: &AppHandle) -> Vec<PendingJavaDownload> {
+    let queue = DownloadQueue::load(app_handle);
+    queue.pending_downloads
+}
+
+#[allow(dead_code)]
+pub fn clear_pending_download(
+    app_handle: &AppHandle,
+    major_version: u32,
+    image_type: &str,
+) -> Result<(), String> {
+    let mut queue = DownloadQueue::load(app_handle);
+    queue.remove(major_version, image_type);
+    queue.save(app_handle)
+}
diff --git a/src-tauri/src/core/java/persistence.rs b/src-tauri/src/core/java/persistence.rs
new file mode 100644
index 0000000..0932f2e
--- /dev/null
+++ b/src-tauri/src/core/java/persistence.rs
@@ -0,0 +1,82 @@
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use tauri::{AppHandle, Manager};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JavaConfig {
+    pub user_defined_paths: Vec<String>,
+    pub preferred_java_path: Option<String>,
+    pub last_detection_time: u64,
+}
+
+impl Default for JavaConfig {
+    fn default() -> Self {
+        Self {
+            user_defined_paths: Vec::new(),
+            preferred_java_path: None,
+            last_detection_time: 0,
+        }
+    }
+}
+
+fn get_java_config_path(app_handle: &AppHandle) -> PathBuf {
+    app_handle
+        .path()
+        .app_data_dir()
+        .unwrap()
+        .join("java_config.json")
+}
+
+pub fn load_java_config(app_handle: &AppHandle) -> JavaConfig {
+    let config_path = get_java_config_path(app_handle);
+    if !config_path.exists() {
+        return JavaConfig::default();
+    }
+
+    match std::fs::read_to_string(&config_path) {
+        Ok(content) => serde_json::from_str(&content).unwrap_or_default(),
+        Err(_) => JavaConfig::default(),
+    }
+}
+
+pub fn save_java_config(app_handle: &AppHandle, config: &JavaConfig) -> Result<(), String> {
+    let config_path = get_java_config_path(app_handle);
+    let content = serde_json::to_string_pretty(config).map_err(|e| e.to_string())?;
+    std::fs::create_dir_all(config_path.parent().unwrap()).map_err(|e| e.to_string())?;
+    std::fs::write(&config_path, content).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+pub fn add_user_defined_path(app_handle: &AppHandle, path: String) -> Result<(), String> {
+    let mut config = load_java_config(app_handle);
+    if !config.user_defined_paths.contains(&path) {
+        config.user_defined_paths.push(path);
+    }
+    save_java_config(app_handle, &config)
+}
+
+pub fn remove_user_defined_path(app_handle: &AppHandle, path: &str) -> Result<(), String> {
+    let mut config = load_java_config(app_handle);
+    config.user_defined_paths.retain(|p| p != path);
+    save_java_config(app_handle, &config)
+}
+
+pub fn set_preferred_java_path(app_handle: &AppHandle, path: Option<String>) -> Result<(), String> {
+    let mut config = load_java_config(app_handle);
+    config.preferred_java_path = path;
+    save_java_config(app_handle, &config)
+}
+
+pub fn get_preferred_java_path(app_handle: &AppHandle) -> Option<String> {
+    let config = load_java_config(app_handle);
+    config.preferred_java_path
+}
+
+pub fn update_last_detection_time(app_handle: &AppHandle) -> Result<(), String> {
+    let mut config = load_java_config(app_handle);
+    config.last_detection_time = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    save_java_config(app_handle, &config)
+}
diff --git a/src-tauri/src/core/java/priority.rs b/src-tauri/src/core/java/priority.rs
new file mode 100644
index 0000000..cf39fdd
--- /dev/null
+++ b/src-tauri/src/core/java/priority.rs
@@ -0,0 +1,72 @@
+use tauri::AppHandle;
+
+use super::JavaInstallation;
+use crate::core::java::persistence;
+use crate::core::java::validation;
+
+pub async fn resolve_java_for_launch(
+	app_handle: &AppHandle,
+	instance_java_override: Option<&str>,
+	global_java_path: Option<&str>,
+	required_major_version: Option<u64>,
+	max_major_version: Option<u32>,
+) -> Option<JavaInstallation> {
+	if let Some(override_path) = instance_java_override {
+		if !override_path.is_empty() {
+			let path_buf = std::path::PathBuf::from(override_path);
+			if let Some(java) = validation::check_java_installation(&path_buf).await {
+				if is_version_compatible(&java, required_major_version, max_major_version) {
+					return Some(java);
+				}
+			}
+		}
+	}
+
+	if let Some(global_path) = global_java_path {
+		if !global_path.is_empty() {
+			let path_buf = std::path::PathBuf::from(global_path);
+			if let Some(java) = validation::check_java_installation(&path_buf).await {
+				if is_version_compatible(&java, required_major_version, max_major_version) {
+					return Some(java);
+				}
+			}
+		}
+	}
+
+	let preferred = persistence::get_preferred_java_path(app_handle);
+	if let Some(pref_path) = preferred {
+		let path_buf = std::path::PathBuf::from(&pref_path);
+		if let Some(java) = validation::check_java_installation(&path_buf).await {
+			if is_version_compatible(&java, required_major_version, max_major_version) {
+				return Some(java);
+			}
+		}
+	}
+
+	let installations = super::detect_all_java_installations(app_handle).await;
+	installations
+		.into_iter()
+		.find(|java| is_version_compatible(java, required_major_version, max_major_version))
+}
+
+fn is_version_compatible(
+    java: &JavaInstallation,
+    required_major_version: Option<u64>,
+    max_major_version: Option<u32>,
+) -> bool {
+    let major = validation::parse_java_version(&java.version);
+
+    let meets_min = if let Some(required) = required_major_version {
+        major >= required as u32
+    } else {
+        true
+    };
+
+    let meets_max = if let Some(max_version) = max_major_version {
+        major <= max_version
+    } else {
+        true
+    };
+
+    meets_min && meets_max
+}
diff --git a/src-tauri/src/core/java/provider.rs b/src-tauri/src/core/java/provider.rs
new file mode 100644
index 0000000..0f9d78a
--- /dev/null
+++ b/src-tauri/src/core/java/provider.rs
@@ -0,0 +1,41 @@
+use crate::core::java::{ImageType, JavaCatalog, JavaDownloadInfo};
+use tauri::AppHandle;
+
+/// Trait for Java download providers (Adoptium, Temurin, Corretto, etc.)
+/// 
+/// Implements SOLID principles:
+/// - Single Responsibility: Each provider handles one download source
+/// - Open/Closed: New providers can be added without modifying existing code
+/// - Liskov Substitution: All providers are interchangeable
+/// - Interface Segregation: Minimal required methods
+/// - Dependency Inversion: Code depends on trait, not concrete implementations
+pub trait JavaProvider: Send + Sync {
+    /// Fetch the Java catalog (all available versions for this provider)
+    async fn fetch_catalog(
+        &self,
+        app_handle: &AppHandle,
+        force_refresh: bool,
+    ) -> Result<JavaCatalog, String>;
+
+    /// Fetch a specific Java release
+    async fn fetch_release(
+        &self,
+        major_version: u32,
+        image_type: ImageType,
+    ) -> Result<JavaDownloadInfo, String>;
+
+    /// Get list of available major versions
+    async fn available_versions(&self) -> Result<Vec<u32>, String>;
+
+    /// Get provider name (e.g., "adoptium", "corretto")
+    fn provider_name(&self) -> &'static str;
+
+    /// Get OS name for this provider's API
+    fn os_name(&self) -> &'static str;
+
+    /// Get architecture name for this provider's API
+    fn arch_name(&self) -> &'static str;
+
+    /// Get installation directory prefix (e.g., "temurin", "corretto")
+    fn install_prefix(&self) -> &'static str;
+}
diff --git a/src-tauri/src/core/java/providers/adoptium.rs b/src-tauri/src/core/java/providers/adoptium.rs
new file mode 100644
index 0000000..dfd4c0e
--- /dev/null
+++ b/src-tauri/src/core/java/providers/adoptium.rs
@@ -0,0 +1,306 @@
+use crate::core::java::provider::JavaProvider;
+use crate::core::java::{ImageType, JavaCatalog, JavaDownloadInfo, JavaReleaseInfo};
+use serde::Deserialize;
+use tauri::AppHandle;
+
+const ADOPTIUM_API_BASE: &str = "https://api.adoptium.net/v3";
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct AdoptiumAsset {
+    pub binary: AdoptiumBinary,
+    pub release_name: String,
+    pub version: AdoptiumVersionData,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[allow(dead_code)]
+pub struct AdoptiumBinary {
+    pub os: String,
+    pub architecture: String,
+    pub image_type: String,
+    pub package: AdoptiumPackage,
+    #[serde(default)]
+    pub updated_at: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct AdoptiumPackage {
+    pub name: String,
+    pub link: String,
+    pub size: u64,
+    pub checksum: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[allow(dead_code)]
+pub struct AdoptiumVersionData {
+    pub major: u32,
+    pub minor: u32,
+    pub security: u32,
+    pub semver: String,
+    pub openjdk_version: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[allow(dead_code)]
+pub struct AvailableReleases {
+    pub available_releases: Vec<u32>,
+    pub available_lts_releases: Vec<u32>,
+    pub most_recent_lts: Option<u32>,
+    pub most_recent_feature_release: Option<u32>,
+}
+
+pub struct AdoptiumProvider;
+
+impl AdoptiumProvider {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for AdoptiumProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl JavaProvider for AdoptiumProvider {
+    async fn fetch_catalog(
+        &self,
+        app_handle: &AppHandle,
+        force_refresh: bool,
+    ) -> Result<JavaCatalog, String> {
+        if !force_refresh {
+            if let Some(cached) = super::super::load_cached_catalog(app_handle) {
+                return Ok(cached);
+            }
+        }
+
+        let os = self.os_name();
+        let arch = self.arch_name();
+        let client = reqwest::Client::new();
+
+        let releases_url = format!("{}/info/available_releases", ADOPTIUM_API_BASE);
+        let available: AvailableReleases = client
+            .get(&releases_url)
+            .header("Accept", "application/json")
+            .send()
+            .await
+            .map_err(|e| format!("Failed to fetch available releases: {}", e))?
+            .json()
+            .await
+            .map_err(|e| format!("Failed to parse available releases: {}", e))?;
+
+        let mut releases = Vec::new();
+
+        for major_version in &available.available_releases {
+            for image_type in &["jre", "jdk"] {
+                let url = format!(
+                    "{}/assets/latest/{}/hotspot?os={}&architecture={}&image_type={}",
+                    ADOPTIUM_API_BASE, major_version, os, arch, image_type
+                );
+
+                match client
+                    .get(&url)
+                    .header("Accept", "application/json")
+                    .send()
+                    .await
+                {
+                    Ok(response) => {
+                        if response.status().is_success() {
+                            if let Ok(assets) = response.json::<Vec<AdoptiumAsset>>().await {
+                                if let Some(asset) = assets.into_iter().next() {
+                                    let release_date = asset.binary.updated_at.clone();
+                                    let release_info = JavaReleaseInfo {
+                                        major_version: *major_version,
+                                        image_type: image_type.to_string(),
+                                        version: asset.version.semver.clone(),
+                                        release_name: asset.release_name.clone(),
+                                        release_date,
+                                        file_size: asset.binary.package.size,
+                                        checksum: asset.binary.package.checksum,
+                                        download_url: asset.binary.package.link,
+                                        is_lts: available
+                                            .available_lts_releases
+                                            .contains(major_version),
+                                        is_available: true,
+                                        architecture: asset.binary.architecture.clone(),
+                                    };
+                                    releases.push(release_info);
+                                }
+                            }
+                        } else {
+                            let release_info = JavaReleaseInfo {
+                                major_version: *major_version,
+                                image_type: image_type.to_string(),
+                                version: format!("{}.x", major_version),
+                                release_name: format!("jdk-{}", major_version),
+                                release_date: None,
+                                file_size: 0,
+                                checksum: None,
+                                download_url: String::new(),
+                                is_lts: available.available_lts_releases.contains(major_version),
+                                is_available: false,
+                                architecture: arch.to_string(),
+                            };
+                            releases.push(release_info);
+                        }
+                    }
+                    Err(_) => {
+                        releases.push(JavaReleaseInfo {
+                            major_version: *major_version,
+                            image_type: image_type.to_string(),
+                            version: format!("{}.x", major_version),
+                            release_name: format!("jdk-{}", major_version),
+                            release_date: None,
+                            file_size: 0,
+                            checksum: None,
+                            download_url: String::new(),
+                            is_lts: available.available_lts_releases.contains(major_version),
+                            is_available: false,
+                            architecture: arch.to_string(),
+                        });
+                    }
+                }
+            }
+        }
+
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+
+        let catalog = JavaCatalog {
+            releases,
+            available_major_versions: available.available_releases,
+            lts_versions: available.available_lts_releases,
+            cached_at: now,
+        };
+
+        let _ = super::super::save_catalog_cache(app_handle, &catalog);
+
+        Ok(catalog)
+    }
+
+    async fn fetch_release(
+        &self,
+        major_version: u32,
+        image_type: ImageType,
+    ) -> Result<JavaDownloadInfo, String> {
+        let os = self.os_name();
+        let arch = self.arch_name();
+
+        let url = format!(
+            "{}/assets/latest/{}/hotspot?os={}&architecture={}&image_type={}",
+            ADOPTIUM_API_BASE, major_version, os, arch, image_type
+        );
+
+        let client = reqwest::Client::new();
+        let response = client
+            .get(&url)
+            .header("Accept", "application/json")
+            .send()
+            .await
+            .map_err(|e| format!("Network request failed: {}", e))?;
+
+        if !response.status().is_success() {
+            return Err(format!(
+                "Adoptium API returned error: {} - The version/platform might be unavailable",
+                response.status()
+            ));
+        }
+
+        let assets: Vec<AdoptiumAsset> = response
+            .json()
+            .await
+            .map_err(|e| format!("Failed to parse API response: {}", e))?;
+
+        let asset = assets
+            .into_iter()
+            .next()
+            .ok_or_else(|| format!("Java {} {} download not found", major_version, image_type))?;
+
+        Ok(JavaDownloadInfo {
+            version: asset.version.semver.clone(),
+            release_name: asset.release_name,
+            download_url: asset.binary.package.link,
+            file_name: asset.binary.package.name,
+            file_size: asset.binary.package.size,
+            checksum: asset.binary.package.checksum,
+            image_type: asset.binary.image_type,
+        })
+    }
+
+    async fn available_versions(&self) -> Result<Vec<u32>, String> {
+        let url = format!("{}/info/available_releases", ADOPTIUM_API_BASE);
+
+        let response = reqwest::get(url)
+            .await
+            .map_err(|e| format!("Network request failed: {}", e))?;
+
+        let releases: AvailableReleases = response
+            .json()
+            .await
+            .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+        Ok(releases.available_releases)
+    }
+
+    fn provider_name(&self) -> &'static str {
+        "adoptium"
+    }
+
+    fn os_name(&self) -> &'static str {
+        #[cfg(target_os = "linux")]
+        {
+            if std::path::Path::new("/etc/alpine-release").exists() {
+                return "alpine-linux";
+            }
+            "linux"
+        }
+        #[cfg(target_os = "macos")]
+        {
+            "mac"
+        }
+        #[cfg(target_os = "windows")]
+        {
+            "windows"
+        }
+        #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+        {
+            "linux"
+        }
+    }
+
+    fn arch_name(&self) -> &'static str {
+        #[cfg(target_arch = "x86_64")]
+        {
+            "x64"
+        }
+        #[cfg(target_arch = "aarch64")]
+        {
+            "aarch64"
+        }
+        #[cfg(target_arch = "x86")]
+        {
+            "x86"
+        }
+        #[cfg(target_arch = "arm")]
+        {
+            "arm"
+        }
+        #[cfg(not(any(
+            target_arch = "x86_64",
+            target_arch = "aarch64",
+            target_arch = "x86",
+            target_arch = "arm"
+        )))]
+        {
+            "x64"
+        }
+    }
+
+    fn install_prefix(&self) -> &'static str {
+        "temurin"
+    }
+}
diff --git a/src-tauri/src/core/java/providers/mod.rs b/src-tauri/src/core/java/providers/mod.rs
new file mode 100644
index 0000000..16eb5c7
--- /dev/null
+++ b/src-tauri/src/core/java/providers/mod.rs
@@ -0,0 +1,3 @@
+pub mod adoptium;
+
+pub use adoptium::AdoptiumProvider;
diff --git a/src-tauri/src/core/java/validation.rs b/src-tauri/src/core/java/validation.rs
new file mode 100644
index 0000000..ec7745d
--- /dev/null
+++ b/src-tauri/src/core/java/validation.rs
@@ -0,0 +1,120 @@
+use std::path::PathBuf;
+use std::process::Command;
+use std::time::Duration;
+
+#[cfg(target_os = "windows")]
+use std::os::windows::process::CommandExt;
+
+use super::JavaInstallation;
+
+const JAVA_CHECK_TIMEOUT: Duration = Duration::from_secs(5);
+
+pub fn strip_unc_prefix(path: PathBuf) -> PathBuf {
+	#[cfg(target_os = "windows")]
+	{
+		let s = path.to_string_lossy().to_string();
+		if s.starts_with(r"\\?\") {
+			return PathBuf::from(&s[4..]);
+		}
+	}
+	path
+}
+
+pub async fn check_java_installation(path: &PathBuf) -> Option<JavaInstallation> {
+	let path = path.clone();
+	tokio::task::spawn_blocking(move || {
+		check_java_installation_blocking(&path)
+	})
+	.await
+	.ok()?
+}
+
+fn check_java_installation_blocking(path: &PathBuf) -> Option<JavaInstallation> {
+	let mut cmd = Command::new(path);
+	cmd.arg("-version");
+	#[cfg(target_os = "windows")]
+	cmd.creation_flags(0x08000000);
+
+	let output = cmd.output().ok()?;
+
+	let version_output = String::from_utf8_lossy(&output.stderr);
+
+	let version = parse_version_string(&version_output)?;
+	let arch = extract_architecture(&version_output);
+	let vendor = extract_vendor(&version_output);
+	let is_64bit = version_output.contains("64-Bit");
+
+	Some(JavaInstallation {
+		path: path.to_string_lossy().to_string(),
+		version,
+		arch,
+		vendor,
+		source: "system".to_string(),
+		is_64bit,
+	})
+}
+
+pub fn parse_version_string(output: &str) -> Option<String> {
+    for line in output.lines() {
+        if line.contains("version") {
+            if let Some(start) = line.find('"') {
+                if let Some(end) = line[start + 1..].find('"') {
+                    return Some(line[start + 1..start + 1 + end].to_string());
+                }
+            }
+        }
+    }
+    None
+}
+
+pub fn parse_java_version(version: &str) -> u32 {
+    let parts: Vec<&str> = version.split('.').collect();
+    if let Some(first) = parts.first() {
+        // Handle both legacy (1.x) and modern (x) versioning
+        if *first == "1" {
+            // Legacy versioning
+            parts.get(1).and_then(|s| s.parse().ok()).unwrap_or(0)
+        } else {
+            // Modern versioning
+            first.parse().unwrap_or(0)
+        }
+    } else {
+        0
+    }
+}
+
+pub fn extract_architecture(version_output: &str) -> String {
+    if version_output.contains("64-Bit") {
+        "x64".to_string()
+    } else if version_output.contains("32-Bit") {
+        "x86".to_string()
+    } else if version_output.contains("aarch64") || version_output.contains("ARM64") {
+        "aarch64".to_string()
+    } else {
+        "x64".to_string()
+    }
+}
+
+pub fn extract_vendor(version_output: &str) -> String {
+    let lower = version_output.to_lowercase();
+
+    if lower.contains("temurin") || lower.contains("adoptium") {
+        "Eclipse Adoptium".to_string()
+    } else if lower.contains("openjdk") {
+        "OpenJDK".to_string()
+    } else if lower.contains("oracle") {
+        "Oracle".to_string()
+    } else if lower.contains("microsoft") {
+        "Microsoft".to_string()
+    } else if lower.contains("zulu") {
+        "Azul Zulu".to_string()
+    } else if lower.contains("corretto") {
+        "Amazon Corretto".to_string()
+    } else if lower.contains("liberica") {
+        "BellSoft Liberica".to_string()
+    } else if lower.contains("graalvm") {
+        "GraalVM".to_string()
+    } else {
+        "Unknown".to_string()
+    }
+}