1 files changed, 199 insertions, 63 deletions

diff --git a/src/minecraft/launcher.rs b/src/minecraft/launcher.rs
index 2eeaf21..3cca948 100644
--- a/src/minecraft/launcher.rs
+++ b/src/minecraft/launcher.rs
@@ -1,64 +1,104 @@
-use std::process::Command;
-
-use log::{debug, info};
+use paths::{client_jar, library_file, natives_dir};
+use serde::Deserialize;
+use std::path::Path;
+use std::process::Output;
+use std::{
+    path::PathBuf,
+    process::{Command, ExitStatus},
+};
+use McError::Process;
 
 use crate::{
-    config::Config,
-    errors::McError,
-    minecraft::manifests::{Library, Version},
-    platform::paths,
+    config::Config, errors::McError, minecraft::manifests::Version,
+    platform::paths, util::fs::library_allowed,
 };
 
-fn build_classpath(
-    config: &Config,
-    version: &Version,
-) -> Result<String, McError> {
-    let sep = if cfg!(windows) { ";" } else { ":" };
-    let mut entries = Vec::new();
+#[derive(Debug, Clone, Deserialize)]
+pub struct JavaRuntime {
+    pub major: u8,
+    pub path: PathBuf,
+}
+
+impl JavaRuntime {
+    fn validate(&self) -> Result<(), McError> {
+        let output: Output = Command::new(&self.path)
+            .arg("-version")
+            .output()
+            .map_err(|e| {
+                McError::Runtime(format!(
+                    "Failed to execute Java at {}: {}",
+                    self.path.display(),
+                    e
+                ))
+            })?;
+
+        if !output.status.success() {
+            return Err(McError::Runtime(format!(
+                "Invalid Java binary: {}",
+                self.path.display()
+            )));
+        }
+
+        Ok(())
+    }
+}
+
+fn required_java_major(java_major: Option<u8>) -> u8 {
+    java_major.unwrap_or(8)
+}
+
+fn resolve_runtime(
+    required: u8,
+    runtimes: &[JavaRuntime],
+) -> Result<PathBuf, McError> {
+    let mut candidates: Vec<&JavaRuntime> = runtimes
+        .iter()
+        .filter(|r| r.major >= required)
+        .collect();
+
+    candidates.sort_by_key(|r| r.major);
+
+    let runtime = candidates.first().ok_or_else(|| {
+        McError::Runtime(format!(
+            "No suitable Java runtime found (required: Java {})",
+            required
+        ))
+    })?;
+
+    runtime.validate()?;
+    Ok(runtime.path.clone())
+}
+
+fn build_classpath(config: &Config, version: &Version) -> String {
+    let system_separator: &str = if cfg!(windows) { ";" } else { ":" };
+    let mut entries: Vec<String> = Vec::new();
 
     for library in &version.libraries {
         if !library_allowed(library) {
             continue;
         }
+
         if let Some(artifact) = &library.downloads.artifact {
-            let path = paths::library_file(config, &artifact.path)?;
+            let path = library_file(config, &artifact.path);
             entries.push(path.to_string_lossy().to_string());
         }
     }
 
-    let client_jar = paths::client_jar(config, &version.id)?;
-    entries.push(client_jar.to_string_lossy().to_string());
+    let client: PathBuf = client_jar(config, &version.id);
+    entries.push(client.to_string_lossy().to_string());
 
-    Ok(entries.join(sep))
+    entries.join(system_separator)
 }
 
-pub fn launch(config: &Config, version: &Version) -> Result<(), McError> {
-    let java = &config.java_path;
-    let classpath = build_classpath(config, version)?;
-    let natives_dir = paths::natives_dir(config, &version.id);
-
-    if !natives_dir.exists() {
-        return Err(McError::Runtime(format!(
-            "Natives folder does not exist: {}",
-            natives_dir.display()
-        )));
-    }
-
-    let asset_index_id = version
-        .asset_index
-        .as_ref()
-        .ok_or_else(|| {
-            McError::Runtime("Missing assetIndex in version.json".into())
-        })?
-        .id
-        .clone();
-
-    info!("Launching Minecraft {}", version.id);
-    debug!("Classpath: {}", classpath);
-    debug!("Natives: {}", natives_dir.display());
-    debug!("Asset index: {}", asset_index_id);
-
-    let mut cmd = Command::new(java);
+fn build_command(
+    java_path: PathBuf,
+    config: &Config,
+    version: &Version,
+    natives_dir: &Path,
+    classpath: String,
+    asset_index_id: String,
+) -> Command {
+    let mut cmd: Command = Command::new(java_path);
 
     cmd.arg(format!("-Xmx{}M", config.max_memory_mb))
         .arg(format!("-Djava.library.path={}", natives_dir.display()));
@@ -76,11 +116,11 @@ pub fn launch(config: &Config, version: &Version) -> Result<(), McError> {
         .arg("--version")
         .arg(&version.id)
         .arg("--gameDir")
-        .arg(paths::game_dir(config))
+        .arg(paths::game_directory(config))
         .arg("--assetsDir")
-        .arg(paths::assets_dir(config))
+        .arg(paths::assets_directory(config))
         .arg("--assetIndex")
-        .arg(&asset_index_id)
+        .arg(asset_index_id)
         .arg("--uuid")
         .arg(&config.uuid)
         .arg("--userProperties")
@@ -90,32 +130,128 @@ pub fn launch(config: &Config, version: &Version) -> Result<(), McError> {
         .arg("--userType")
         .arg("legacy");
 
-    let status = cmd.status()?;
+    cmd
+}
+
+pub fn launch(config: &Config, version: &Version) -> Result<(), McError> {
+    let required: u8 = required_java_major(
+        version
+            .java_version
+            .as_ref()
+            .map(|j| j.major_version),
+    );
+
+    let java_path: PathBuf = resolve_runtime(required, &config.runtimes)?;
+
+    let classpath: String = build_classpath(config, version);
+    let natives_dir: PathBuf = natives_dir(config, &version.id);
+
+    if !natives_dir.exists() {
+        return Err(McError::Runtime(format!(
+            "Natives folder does not exist: {}",
+            natives_dir.display()
+        )));
+    }
+
+    let asset_index_id = version
+        .asset_index
+        .as_ref()
+        .ok_or_else(|| {
+            McError::Runtime("Missing assetIndex in version.json".into())
+        })?
+        .id
+        .clone();
+
+    let mut cmd: Command = build_command(
+        java_path,
+        config,
+        version,
+        &natives_dir,
+        classpath,
+        asset_index_id,
+    );
+
+    let status: ExitStatus = cmd.status()?;
 
     if !status.success() {
-        return Err(McError::Process("Minecraft exited with error".into()));
+        return Err(Process("Minecraft exited with error".into()));
     }
 
     Ok(())
 }
 
-fn library_allowed(lib: &Library) -> bool {
-    let rules = match &lib.rules {
-        | Some(r) => r,
-        | None => return true,
-    };
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn required_java_major_defaults_to_8() {
+        assert_eq!(required_java_major(None), 8);
+    }
+
+    #[test]
+    fn required_java_major_uses_given_value() {
+        assert_eq!(required_java_major(Some(17)), 17);
+    }
+
+    #[test]
+    fn resolve_runtime_errors_when_no_runtimes() {
+        let runtimes: Vec<JavaRuntime> = vec![];
+        assert!(resolve_runtime(17, &runtimes).is_err());
+    }
+
+    #[test]
+    fn resolve_runtime_picks_lowest_matching_major() {
+        let runtimes: Vec<JavaRuntime> = vec![
+            JavaRuntime {
+                major: 21,
+                path: PathBuf::from("/bin/true"),
+            },
+            JavaRuntime {
+                major: 17,
+                path: PathBuf::from("/bin/true"),
+            },
+        ];
+
+        let result: PathBuf = resolve_runtime(8, &runtimes).unwrap();
+        assert_eq!(result, PathBuf::from("/bin/true"));
+    }
 
-    let mut allowed = false;
+    #[test]
+    fn resolve_runtime_respects_required_version() {
+        let runtimes: Vec<JavaRuntime> = vec![
+            JavaRuntime {
+                major: 8,
+                path: PathBuf::from("/bin/true"),
+            },
+            JavaRuntime {
+                major: 17,
+                path: PathBuf::from("/bin/true"),
+            },
+        ];
+
+        let result: PathBuf = resolve_runtime(17, &runtimes).unwrap();
+        assert_eq!(result, PathBuf::from("/bin/true"));
+    }
 
-    for rule in rules {
-        let os_match = match &rule.os {
-            | Some(os) => os.name == "linux",
-            | None => true,
+    #[test]
+    fn validate_succeeds_for_true_binary() {
+        let runtime = JavaRuntime {
+            major: 17,
+            path: PathBuf::from("/bin/true"),
         };
-        if os_match {
-            allowed = rule.action == "allow";
-        }
+
+        assert!(runtime.validate().is_ok());
     }
 
-    allowed
+    #[test]
+    fn validate_fails_for_false_binary() {
+        let runtime = JavaRuntime {
+            major: 17,
+            path: PathBuf::from("/bin/false"),
+        };
+
+        assert!(runtime.validate().is_err());
+    }
 }