Add Saving and Loading Presets (#40)

* Add Saving and Loading Presets

* Feedback

Author: OpenSauce

Cargo.lock

@@ -16,6 +16,7 @@ chrono = "0.4"
 clap = {version = "4.5", features = ["derive", "env"] }
 rubato = "0.16"
 serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 crossbeam = "0.8"
 iced = "0.13"
 log = "0.4"

Cargo.toml

@@ -0,0 +1,35 @@
+{
+  "name": "Clean",
+  "description": "Clean and pristine tone with subtle warmth",
+  "author": "Rustortion",
+  "stages": [
+    {
+      "Filter": {
+        "filter_type": "Highpass",
+        "cutoff_hz": 80.0,
+        "resonance": 0.0
+      }
+    },
+    {
+      "Preamp": {
+        "gain": 2.0,
+        "bias": 0.0,
+        "clipper_type": "Soft"
+      }
+    },
+    {
+      "ToneStack": {
+        "model": "American",
+        "bass": 0.6,
+        "mid": 0.5,
+        "treble": 0.7,
+        "presence": 0.4
+      }
+    },
+    {
+      "Level": {
+        "gain": 0.8
+      }
+    }
+  ]
+}

presets/Clean.json

@@ -0,0 +1,44 @@
+{
+  "name": "Crunch",
+  "description": "Classic rock crunch with mid-forward character",
+  "author": "Rustortion",
+  "stages": [
+    {
+      "Filter": {
+        "filter_type": "Highpass",
+        "cutoff_hz": 100.0,
+        "resonance": 0.1
+      }
+    },
+    {
+      "Preamp": {
+        "gain": 6.0,
+        "bias": 0.1,
+        "clipper_type": "Medium"
+      }
+    },
+    {
+      "ToneStack": {
+        "model": "British",
+        "bass": 0.5,
+        "mid": 0.7,
+        "treble": 0.6,
+        "presence": 0.5
+      }
+    },
+    {
+      "Compressor": {
+        "attack_ms": 2.0,
+        "release_ms": 50.0,
+        "threshold_db": -15.0,
+        "ratio": 3.0,
+        "makeup_db": 3.0
+      }
+    },
+    {
+      "Level": {
+        "gain": 0.9
+      }
+    }
+  ]
+}

presets/Crunch.json

@@ -0,0 +1,44 @@
+{
+  "name": "Lead",
+  "description": "High-gain lead tone with sustain and clarity",
+  "author": "Rustortion",
+  "stages": [
+    {
+      "Filter": {
+        "filter_type": "Highpass",
+        "cutoff_hz": 120.0,
+        "resonance": 0.2
+      }
+    },
+    {
+      "Preamp": {
+        "gain": 8.5,
+        "bias": 0.0,
+        "clipper_type": "Asymmetric"
+      }
+    },
+    {
+      "ToneStack": {
+        "model": "Modern",
+        "bass": 0.4,
+        "mid": 0.8,
+        "treble": 0.7,
+        "presence": 0.6
+      }
+    },
+    {
+      "Compressor": {
+        "attack_ms": 1.0,
+        "release_ms": 80.0,
+        "threshold_db": -12.0,
+        "ratio": 4.0,
+        "makeup_db": 6.0
+      }
+    },
+    {
+      "Level": {
+        "gain": 1.1
+      }
+    }
+  ]
+}

presets/Lead.json

@@ -1,28 +1,64 @@
 use iced::{Element, Length, Task, Theme};
 use log::{error, info};
 
-use crate::gui::components::{control::Control, stage_list::StageList};
+use crate::gui::components::{control::Control, preset_bar::PresetBar, stage_list::StageList};
 use crate::gui::config::{StageConfig, StageType};
 use crate::gui::messages::{Message, StageMessage};
+use crate::gui::preset::{Preset, PresetManager};
 use crate::io::manager::ProcessorManager;
 use crate::sim::chain::AmplifierChain;
 
-#[derive(Debug)]
 pub struct AmplifierApp {
     processor_manager: ProcessorManager,
     stages: Vec<StageConfig>,
     selected_stage_type: StageType,
     is_recording: bool,
+    preset_manager: PresetManager,
+    selected_preset: Option<String>,
+    preset_bar: PresetBar,
+    new_preset_name: String,
+    show_save_input: bool,
 }
 
 impl AmplifierApp {
     pub fn new(processor_manager: ProcessorManager) -> Self {
-        Self {
+        let preset_manager = PresetManager::new("./presets").unwrap_or_else(|e| {
+            error!("Failed to create preset manager: {e}");
+            // Create an empty preset manager as fallback
+            PresetManager::new(std::env::temp_dir().join("rustortion_presets_fallback"))
+                .expect("Failed to create fallback preset manager")
+        });
+
+        let presets = preset_manager.get_presets();
+        let selected_preset = presets.first().map(|p| p.name.clone());
+        let preset_bar = PresetBar::new(presets, selected_preset.clone());
+
+        // Load the first preset if available
+        let stages = if let Some(preset_name) = &selected_preset {
+            preset_manager
+                .get_preset_by_name(preset_name)
+                .map(|p| p.stages.clone())
+                .unwrap_or_default()
+        } else {
+            Vec::new()
+        };
+
+        let app = Self {
             processor_manager,
-            stages: Vec::new(),
+            stages,
             selected_stage_type: StageType::default(),
             is_recording: false,
-        }
+            preset_manager,
+            selected_preset,
+            preset_bar,
+            new_preset_name: String::new(),
+            show_save_input: false,
+        };
+
+        // Update the processor chain with the loaded preset
+        app.update_processor_chain();
+
+        app
     }
 
     pub fn update(&mut self, message: Message) -> Task<Message> {
@@ -55,6 +91,103 @@ impl AmplifierApp {
             Message::StageTypeSelected(stage_type) => {
                 self.selected_stage_type = stage_type;
             }
+            Message::PresetSelected(preset_name) => {
+                if let Some(preset) = self.preset_manager.get_preset_by_name(&preset_name) {
+                    self.stages = preset.stages.clone();
+                    self.selected_preset = Some(preset_name.clone());
+                    self.preset_bar
+                        .set_selected_preset(Some(preset_name.clone()));
+                    should_update_chain = true;
+                    info!("Loaded preset: {preset_name}");
+                }
+            }
+            Message::ShowSavePreset => {
+                self.show_save_input = true;
+                self.preset_bar.show_save_input(true);
+            }
+            Message::CancelSavePreset => {
+                self.show_save_input = false;
+                self.new_preset_name.clear();
+                self.preset_bar.show_save_input(false);
+            }
+            Message::PresetNameChanged(name) => {
+                self.new_preset_name = name.clone();
+                self.preset_bar.set_new_preset_name(name);
+            }
+            Message::SavePreset => {
+                if !self.new_preset_name.trim().is_empty() {
+                    let preset = Preset::new(self.new_preset_name.clone(), self.stages.clone());
+
+                    match self.preset_manager.save_preset(&preset) {
+                        Ok(()) => {
+                            info!("Saved preset: {}", self.new_preset_name);
+                            self.selected_preset = Some(self.new_preset_name.clone());
+                            self.preset_bar
+                                .update_presets(self.preset_manager.get_presets());
+                            self.preset_bar
+                                .set_selected_preset(Some(self.new_preset_name.clone()));
+                            self.show_save_input = false;
+                            self.preset_bar.show_save_input(false);
+                            self.new_preset_name.clear();
+                        }
+                        Err(e) => {
+                            error!("Failed to save preset: {e}");
+                        }
+                    }
+                }
+            }
+            Message::UpdateCurrentPreset => {
+                if let Some(ref preset_name) = self.selected_preset {
+                    let preset = Preset::new(preset_name.clone(), self.stages.clone());
+
+                    match self.preset_manager.save_preset(&preset) {
+                        Ok(()) => {
+                            info!("Updated preset: {preset_name}");
+                            self.preset_bar
+                                .update_presets(self.preset_manager.get_presets());
+                        }
+                        Err(e) => {
+                            error!("Failed to update preset: {e}");
+                        }
+                    }
+                }
+            }
+            Message::DeletePreset(preset_name) => {
+                match self.preset_manager.delete_preset(&preset_name) {
+                    Ok(()) => {
+                        info!("Deleted preset: {preset_name}");
+                        self.preset_bar
+                            .update_presets(self.preset_manager.get_presets());
+
+                        // Clear selection if we deleted the current preset
+                        if self.selected_preset.as_ref() == Some(&preset_name) {
+                            self.selected_preset = None;
+                            self.preset_bar.set_selected_preset(None);
+                            // Optionally load the first available preset or clear stages
+                            if let Some(first_preset) = self.preset_manager.get_presets().first() {
+                                self.stages = first_preset.stages.clone();
+                                self.selected_preset = Some(first_preset.name.clone());
+                                self.preset_bar
+                                    .set_selected_preset(Some(first_preset.name.clone()));
+                            } else {
+                                self.stages.clear();
+                            }
+
+                            should_update_chain = true;
+                        }
+                    }
+                    Err(e) => {
+                        error!("Failed to delete preset: {e}");
+                    }
+                }
+            }
+            Message::ConfirmOverwritePreset => {
+                self.save_current_preset();
+                self.preset_bar.hide_overwrite_confirmation();
+            }
+            Message::CancelOverwritePreset => {
+                self.preset_bar.hide_overwrite_confirmation();
+            }
             Message::StartRecording => match self.processor_manager.enable_recording() {
                 Ok(()) => {
                     self.is_recording = true;
@@ -149,6 +282,26 @@ impl AmplifierApp {
         }
     }
 
+    fn save_current_preset(&mut self) {
+        let preset = Preset::new(self.new_preset_name.clone(), self.stages.clone());
+
+        match self.preset_manager.save_preset(&preset) {
+            Ok(()) => {
+                info!("Saved preset: {}", self.new_preset_name);
+                self.selected_preset = Some(self.new_preset_name.clone());
+                self.preset_bar
+                    .update_presets(self.preset_manager.get_presets());
+                self.preset_bar
+                    .set_selected_preset(Some(self.new_preset_name.clone()));
+                self.show_save_input = false;
+                self.preset_bar.show_save_input(false);
+                self.new_preset_name.clear();
+            }
+            Err(e) => {
+                error!("Failed to save preset: {e}");
+            }
+        }
+    }
     fn update_processor_chain(&self) {
         let sample_rate = self.processor_manager.sample_rate();
         let chain = build_amplifier_chain(&self.stages, sample_rate);
@@ -160,6 +313,7 @@ impl AmplifierApp {
 
         container(
             column![
+                self.preset_bar.view(),
                 StageList::new(&self.stages).view(),
                 Control::new(self.selected_stage_type, self.is_recording).view()
             ]