more profile management stuff

2 files changed, 55 insertions, 8 deletions

diff --git a/ozone-cli/src/cli.rs b/ozone-cli/src/cli.rs
index f60c4d2..ad5769b 100644
--- a/ozone-cli/src/cli.rs
+++ b/ozone-cli/src/cli.rs
@@ -124,7 +124,10 @@ pub struct InstanceCreateArgs {
 pub enum InstanceCommand {

     Select(InstanceSelectArgs),

     Create(InstanceCreateArgs),

-    List

+    Set(InstanceSettingsArgs),

+    Delete,

+    List,

+    Info

 }

 

 #[derive(Args, Debug)]

diff --git a/ozone-cli/src/main.rs b/ozone-cli/src/main.rs
index dc4ca4c..d857cd1 100644
--- a/ozone-cli/src/main.rs
+++ b/ozone-cli/src/main.rs
@@ -4,7 +4,7 @@ use std::error::Error;
 use std::process::ExitCode;
 use log::{error, info, trace, LevelFilter};
 use clap::Parser;
-use ozone::launcher::{Instance, Launcher, Settings};
+use ozone::launcher::{Instance, JavaRuntimeSetting, Launcher, Settings};
 use ozone::launcher::version::{VersionList, VersionResult};
 use uuid::Uuid;
 use crate::cli::{Cli, InstanceCommand, RootCommand};
@@ -39,7 +39,7 @@ async fn main_inner(cli: Cli) -> Result<ExitCode, Box<dyn Error>> {
                     let sel = if settings.selected_instance.is_some_and(|id| id == cur_id) { " (selected)" } else { "" };
 
                     println!("Instance `{}'{sel}:", instance.name);
-                    println!("  Id: {}", cur_id);
+                    println!("  UUID: {}", cur_id);
                     println!("  Version: {}", instance.game_version);
                     println!("  Location: {}", home.join(Settings::get_instance_path(cur_id)).display());
                 }
@@ -85,7 +85,7 @@ async fn main_inner(cli: Cli) -> Result<ExitCode, Box<dyn Error>> {
             },
             InstanceCommand::Select(args) => {
                 if let Ok(uuid) = args.instance.parse::<Uuid>() {
-                    if settings.instances.get(&uuid).is_none() {
+                    if !settings.instances.contains_key(&uuid) {
                         eprintln!("No instances were found by that UUID.");
                         return Ok(ExitCode::FAILURE);
                     }
@@ -123,15 +123,59 @@ async fn main_inner(cli: Cli) -> Result<ExitCode, Box<dyn Error>> {
 
                 settings.selected_instance = Some(**found_id);
                 settings.save().await?;
+            },
+            InstanceCommand::Set(args) => {
+                let Some(inst) = settings.selected_instance.and_then(|i| settings.instances.get_mut(&i)) else {
+                    eprintln!("No instance selected.");
+                    return Ok(ExitCode::FAILURE);
+                };
+
+                args.apply_to(inst);
+                settings.save().await?;
+            },
+            InstanceCommand::Delete => {
+                let Some(inst) = settings.selected_instance else {
+                    eprintln!("No instance selected.");
+                    return Ok(ExitCode::FAILURE);
+                };
+
+                settings.instances.remove(&inst);
+                settings.selected_instance = None;
+                settings.save().await?;
+            },
+            InstanceCommand::Info => {
+                let Some(inst) = settings.selected_instance.and_then(|i| settings.instances.get(&i)) else {
+                    eprintln!("No instance selected.");
+                    return Ok(ExitCode::FAILURE);
+                };
+                
+                println!("Information for selected profile `{}' ({}):", inst.name, settings.selected_instance.unwrap());
+                println!("  Version: {}", inst.game_version);
+                
+                match &inst.java_runtime {
+                    Some(JavaRuntimeSetting::Component(c)) => println!("  Java runtime component: {c}"),
+                    Some(JavaRuntimeSetting::Path(p)) => println!("  Java runtime path: {}", p.display()),
+                    _ => ()
+                }
+                
+                if let Some(res) = inst.resolution {
+                    println!("  Game resolution: {}x{}", res.width, res.height);
+                }
             }
         },
         RootCommand::Launch => {
+            let Some(selection) = settings.selected_instance else {
+                eprintln!("No instance selected.");
+                return Ok(ExitCode::FAILURE);
+            };
+            
+            let inst = settings.instances.get(&selection).expect("settings inconsistency");
+
             settings.save().await?;
 
-/*            let launcher = Launcher::new(&home, !cli.offline).await?;
-            let profile = settings.get_profiles().get("default").unwrap();
+            let launcher = Launcher::new(&home, !cli.offline).await?;
 
-            let launch = launcher.prepare_launch(profile, settings.get_instances().get(profile.get_instance_name()).unwrap(), settings.get_client_id()).await.map_err(|e| {
+            let launch = launcher.prepare_launch(inst, Settings::get_instance_path(selection), settings.client_id).await.map_err(|e| {
                 error!("error launching: {e}");
                 e
             })?;
@@ -139,7 +183,7 @@ async fn main_inner(cli: Cli) -> Result<ExitCode, Box<dyn Error>> {
             dbg!(&launch);
             info!("ok");
 
-            ozone::launcher::run_the_game(&launch)?;*/
+            ozone::launcher::run_the_game(&launch)?;
         }
         _ => todo!()
     }