Cleaned up dead code comments

Locating the among us folder and launching the app are one in the same, need GUI work to allow it to update after location

More and changed log messages

src/main.rs

@@ -21,6 +21,7 @@ struct Delegate;
 #[derive(Data, Clone)]
 struct AppData {
     pub among_us_path: Rc<RefCell<String>>,
+    pub installs_path: String,
 }
 
 static AMONG_US_APPID: &str = "945360";
@@ -36,6 +37,7 @@ fn attempt_run_among_us(install_path: &Path) {
 }
 
 fn unmod_among_us_folder(folder_path: &Path) {
+    println!("Unmodding Among Us...");
     let doorstop_path: PathBuf = [folder_path.to_str().unwrap(), "doorstop_config.ini"]
         .iter()
         .collect();
@@ -45,6 +47,7 @@ fn unmod_among_us_folder(folder_path: &Path) {
     let winhttp_path: PathBuf = [folder_path.to_str().unwrap(), "winhttp.dll"]
         .iter()
         .collect();
+
     let bepinex_path: PathBuf = [folder_path.to_str().unwrap(), "BepInEx"].iter().collect();
     let mono_path: PathBuf = [folder_path.to_str().unwrap(), "mono"].iter().collect();
     fs::remove_file(doorstop_path).unwrap_or_default();
@@ -124,6 +127,7 @@ impl AppDelegate<AppData> for Delegate {
             println!("{}", buf.to_str().unwrap());
             println!("Handled!");
             Application::global().quit();
+
             return Handled::Yes;
         }
         Handled::No
@@ -137,7 +141,6 @@ async fn main() {
 
     println!("Updater Version: {}", version);
     get_latest_updater_version().await.unwrap();
-    //let _version_check_thread_handle = thread::spawn(move || get_latest_updater_version());
 
     // CREATE PROGRAM DIRECTORY
     let mut data_path = dirs::data_dir().unwrap();
@@ -148,6 +151,13 @@ async fn main() {
     installs_path.push("installs");
     fs::create_dir(installs_path.clone()).unwrap_or(());
 
+    let app_data: AppData = AppData {
+        among_us_path: Rc::new(RefCell::new(String::from(""))),
+        installs_path: String::from(""),
+    };
+
+    let mut root_column: druid::widget::Flex<AppData> = druid::widget::Flex::column();
+
     // DETERMINE AMONG US VERSION
 
     let mut among_us_folder = PathBuf::new();
@@ -156,17 +166,13 @@ async fn main() {
     existing_file_path.push("existing_among_us_dir.txt");
     let existing_found_folder = fs::read_to_string(existing_file_path.clone());
 
-    if existing_found_folder.is_ok() {
+    if let Ok(existing_folder) = existing_found_folder {
-        among_us_folder.push(existing_found_folder.unwrap());
+        among_us_folder.push(existing_folder);
     } else {
         let folder_opt = detect_among_us_folder();
         if folder_opt.is_some() {
             among_us_folder.push(folder_opt.unwrap());
         } else {
-            let path_rc = Rc::new(RefCell::new(String::from("")));
-            let data: AppData = AppData {
-                among_us_path: path_rc.clone(),
-            };
             let open_button = Button::new("Locate Among Us").fix_height(45.0).on_click(
                 move |ctx, _: &mut AppData, _| {
                     ctx.submit_command(
@@ -174,51 +180,45 @@ async fn main() {
                     );
                 },
             );
-            let flex: Flex<AppData> = Flex::column().with_flex_child(open_button, 1.0);
-            let open_dialog = WindowDesc::new(|| flex)
-                .title("Among Us Not Found!")
-                .window_size((400.0, 400.0));
-            AppLauncher::with_window(open_dialog)
-                .delegate(Delegate)
-                .launch(data)
-                .unwrap_or_default();
 
-            among_us_folder = PathBuf::from(Rc::try_unwrap(path_rc).unwrap().take());
+            // If we can't find Among Us, add the locate button.
+            // TODO: make this button then update the UI assuming it's valid
 
-            println!("{}", among_us_folder.to_str().unwrap());
+            root_column.add_flex_child(open_button, 1.0);
-
-            // win.modal_msg(&ui, "Find Among Us", "On the following Open File dialog, navigate to your Among Us folder and select Among Us.exe");
-            // let open_window = win.open_file(&ui);
-            // println!("{}", open_window.unwrap().to_str().unwrap());
-            // among_us_folder = open_window.unwrap().clone();
 
             // Pop the selected file off the end of the path
             // among_us_folder.pop();
         }
+
+        if among_us_folder.exists() {
             fs::write(existing_file_path, among_us_folder.to_str().unwrap()).unwrap();
         }
+    }
 
-    println!("Among Us Folder: {}", among_us_folder.to_str().unwrap());
+    if let Some(among_us_folder_str) = among_us_folder.to_str() {
+        if among_us_folder_str.len() > 0 {
+            println!("Among Us Folder: {}", among_us_folder_str);
+        } else {
+            println!("Among Us Folder not automatically determined");
+        }
+    }
 
-    let among_us_version =
+    if let Some(among_us_version) =
-        determine_among_us_version(String::from(among_us_folder.to_str().unwrap())).unwrap();
+        determine_among_us_version(String::from(among_us_folder.to_str().unwrap()))
+    {
         println!("AmongUsVersion: {}", among_us_version);
         let ver_url: (String, String, bool) =
             determine_town_of_us_url(among_us_version.to_string().clone())
                 .await
                 .unwrap();
 
-    let version_smash = format!(
+        let version_smash = format!("{}-{}", among_us_version, ver_url.0.clone());
-        "{}-{}",
-        among_us_version,
-        ver_url.0.clone()
-    );
         let new_installed_path: PathBuf = [installs_path.to_str().unwrap(), version_smash.as_str()]
             .iter()
             .collect();
 
         if !Path::exists(&new_installed_path) {
-        println!("Copying Among Us to separate location...");
+            println!("Copying Among Us to cache location...");
             copy_folder_to_target(
                 among_us_folder.to_str().unwrap(),
                 installs_path.to_str().unwrap(),
@@ -263,7 +263,7 @@ async fn main() {
             }
 
             let opened_zip = fs::File::open(download_path).unwrap();
-        println!("Extracting...");
+            println!("Extracting mod zip file...");
             let mut archive = zip::ZipArchive::new(opened_zip).unwrap();
             archive.extract(data_path.clone()).unwrap();
 
@@ -272,7 +272,8 @@ async fn main() {
                 root_folder_path = String::from(i.split('/').next().unwrap());
                 break;
             }
-        let extracted_path: PathBuf = [data_path.to_str().unwrap(), root_folder_path.as_str(), "."]
+            let extracted_path: PathBuf =
+                [data_path.to_str().unwrap(), root_folder_path.as_str(), "."]
                     .iter()
                     .collect();
             println!("{}", extracted_path.to_str().unwrap());
@@ -286,7 +287,6 @@ async fn main() {
 
         // Find existing installs, make buttons for them
         let install_iter = fs::read_dir(installs_path.clone());
-    let mut root_column: druid::widget::Flex<u32> = druid::widget::Flex::column();
 
         if let Ok(iter) = install_iter {
             let mut collection: Vec<Result<fs::DirEntry, io::Error>> = iter.collect();
@@ -294,7 +294,7 @@ async fn main() {
 
             // Iterate first to find labels:
 
-        let mut flexbox_array: Vec<druid::widget::Flex<u32>> = Vec::new();
+            let mut flexbox_array: Vec<druid::widget::Flex<AppData>> = Vec::new();
             let mut auv_array: Vec<String> = Vec::new();
 
             for i in &collection {
@@ -303,7 +303,7 @@ async fn main() {
                 let auv = ver_smash_split.next().unwrap();
                 if !auv_array.contains(&auv.to_string()) {
                     let label_text = format!("Among Us {}", auv);
-                let flex: druid::widget::Flex<u32> = druid::widget::Flex::column()
+                    let flex: druid::widget::Flex<AppData> = druid::widget::Flex::column()
                         .with_flex_child(
                             druid::widget::Label::new(label_text.as_str()).with_text_size(24.0),
                             1.0,
@@ -314,40 +314,60 @@ async fn main() {
                 }
             }
 
+            println!("Installs list:");
+
             for i in collection {
                 let existing_ver_smash = i.unwrap().file_name();
                 let mut ver_smash_split = existing_ver_smash.to_str().unwrap().split('-');
                 let auv = ver_smash_split.next().unwrap();
-            let button_string: String = format!("Town of Us {}", ver_smash_split.next().unwrap());
+                let button_string: String =
+                    format!("Town of Us {}", ver_smash_split.next().unwrap());
 
                 for (index, j) in auv_array.iter().enumerate() {
                     if j == auv {
                         let mut clone = installs_path.clone();
                         clone.push(existing_ver_smash.clone());
 
+                        let mut button_row: Flex<AppData> = Flex::row();
+
                         let fybutton = druid::widget::Button::new(button_string.as_str())
                             .fix_height(45.0)
-                        .on_click(move |_, _: &mut u32, _| {
+                            .center()
+                            .on_click(move |_, _: &mut AppData, _| {
                                 attempt_run_among_us(&clone);
                             });
 
+                        button_row.add_flex_child(fybutton, 1.0);
+
+                        // TODO: Uncomment
+                        // let delete_button = druid::widget::Button::new("Delete")
+                        //     .fix_height(45.0)
+                        //     .on_click(move |_, _: &mut AppData, _| {});
+
+                        // button_row.add_flex_child(delete_button, 1.0);
+
                         flexbox_array
                             .get_mut(index)
                             .unwrap()
-                        .add_flex_child(fybutton, 1.0);
+                            .add_flex_child(button_row, 1.0);
 
-                    println!("{}", existing_ver_smash.clone().to_str().unwrap());
+                        println!("- {}", existing_ver_smash.clone().to_str().unwrap());
                     }
                 }
             }
+
             for i in flexbox_array {
                 root_column.add_flex_child(i, 1.0);
             }
         }
+    }
 
     // println!("Checking for updater updates...");
     // let vals: (String, String) = version_check_thread_handle.join().unwrap();
 
+    // TODO: Auto launch latest sanctioned if the user has a setting like that
+    //       Auto launch latest experimental as well
+
     println!("Launching main window...");
 
     let main_window = WindowDesc::new(|| root_column)
@@ -355,8 +375,7 @@ async fn main() {
         .window_size((400.0, 400.0));
     let app_launcher = AppLauncher::with_window(main_window);
     let _external_handler = app_launcher.get_external_handle();
-    app_launcher.launch(1).unwrap();
+    app_launcher.launch(app_data).unwrap();
-    // AppLauncher::with_window(main_window).launch(1).unwrap();
 
     // let mut install_folder_path = installs_path.clone();
     // install_folder_path.push(version_smash);
@@ -420,9 +439,7 @@ fn determine_among_us_version(folder_root: String) -> Option<AmongUsVersion> {
 
     let target_bytes: [u8; TARGET_BYTES_LEN] = [3, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0];
 
-    let file_bytes = fs::read(asset_file).unwrap();
+    if let Ok(file_bytes) = fs::read(asset_file) {
-    //println!("{:?}", file_bytes);
-
         let mut bytes_str = String::new();
         let mut target_head = 0;
         let mut file_index = 0;
@@ -446,6 +463,11 @@ fn determine_among_us_version(folder_root: String) -> Option<AmongUsVersion> {
         Some(AmongUsVersion::from(
             str::from_utf8(file_bytes.get(file_index..file_index + offset).unwrap()).unwrap(),
         ))
+    } else {
+        None
+    }
+
+    //println!("{:?}", file_bytes);
 }
 
 fn copy_folder_to_target<T: AsRef<Path>>(source: T, dest: T) {