Add project re-assignment

src/app.rs

@@ -9,6 +9,7 @@ pub enum Screen {
     Help,
     ConfigHelp,
     NewEntry,
+    ReassignProject,
 }
 
 pub struct App {
@@ -20,6 +21,8 @@ pub struct App {
     pub new_entry_project: String,
     pub new_entry_cursor: usize,
     pub new_entry_mode: NewEntryMode, // Task or Project
+    pub reassign_project_buffer: String,
+    pub reassign_project_cursor: usize,
     pub status_message: Option<(String, std::time::Instant)>,
 }
 
@@ -39,6 +42,8 @@ impl App {
             new_entry_project: String::new(),
             new_entry_cursor: 0,
             new_entry_mode: NewEntryMode::Task,
+            reassign_project_buffer: String::new(),
+            reassign_project_cursor: 0,
             status_message: None,
         })
     }
@@ -52,6 +57,7 @@ impl App {
             Screen::Help => self.handle_help_event(event),
             Screen::ConfigHelp => self.handle_config_help_event(event),
             Screen::NewEntry => self.handle_new_entry_event(event),
+            Screen::ReassignProject => self.handle_reassign_project_event(event),
         }
     }
 
@@ -72,6 +78,7 @@ impl App {
                 (KeyCode::Char('?'), _) => self.current_screen = Screen::Help,
                 (KeyCode::Char('c'), _) => self.edit_app_config()?,
                 (KeyCode::Char('n'), _) => self.start_new_entry(),
+                (KeyCode::Char('p'), _) => self.start_reassign_project(),
                 (KeyCode::Char('d'), _) => self.delete_current_item()?,
                 _ => {}
             },
@@ -193,6 +200,50 @@ impl App {
         Ok(false)
     }
 
+    fn handle_reassign_project_event(&mut self, event: Event) -> anyhow::Result<bool> {
+        match event {
+            Event::Key(KeyEvent {
+                code, modifiers, ..
+            }) => {
+                match (code, modifiers) {
+                    (KeyCode::Esc, _) => {
+                        self.current_screen = Screen::Main;
+                        self.reassign_project_buffer.clear();
+                        self.reassign_project_cursor = 0;
+                    }
+                    (KeyCode::Enter, _) => {
+                        if self.reassign_project_buffer.is_empty()
+                            || self.config.is_valid_project(&self.reassign_project_buffer)
+                        {
+                            self.reassign_project_for_current_item()?;
+                            self.current_screen = Screen::Main;
+                            self.reassign_project_buffer.clear();
+                            self.reassign_project_cursor = 0;
+                        }
+                    }
+                    (KeyCode::Backspace, _) => {
+                        if self.reassign_project_cursor > 0 {
+                            let idx = self.reassign_project_cursor - 1;
+                            if idx < self.reassign_project_buffer.len() {
+                                self.reassign_project_buffer.remove(idx);
+                                self.reassign_project_cursor -= 1;
+                            }
+                        }
+                    }
+                    (KeyCode::Char(c), m) if m.is_empty() => {
+                        if self.reassign_project_cursor <= self.reassign_project_buffer.len() {
+                            self.reassign_project_buffer.insert(self.reassign_project_cursor, c);
+                            self.reassign_project_cursor += 1;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
+        }
+        Ok(false)
+    }
+
     fn move_selection(&mut self, delta: i32) {
         let items_len = match self.state.current_pane {
             0 => self.state.permanent_items.len(),
@@ -319,6 +370,54 @@ impl App {
         self.new_entry_mode = NewEntryMode::Task;
     }
 
+    fn start_reassign_project(&mut self) {
+        if let Some(item) = self.get_current_item() {
+            self.current_screen = Screen::ReassignProject;
+            // Pre-fill with current project if it exists
+            self.reassign_project_buffer = item.tags.first().cloned().unwrap_or_default();
+            self.reassign_project_cursor = self.reassign_project_buffer.len();
+        }
+    }
+
+    fn reassign_project_for_current_item(&mut self) -> anyhow::Result<()> {
+        let items = match self.state.current_pane {
+            0 => &mut self.state.permanent_items,
+            1 => &mut self.state.recurring_items,
+            2 => &mut self.state.recent_items,
+            _ => return Ok(()),
+        };
+
+        let index = self.state.selected_indices[self.state.current_pane];
+
+        let needs_restart = if let Some(item) = items.get_mut(index) {
+            // Update the tags
+            if self.reassign_project_buffer.is_empty() {
+                item.tags.clear();
+            } else {
+                item.tags = vec![self.reassign_project_buffer.clone()];
+            }
+
+            // Check if this is the active timer
+            self.state
+                .active_timer
+                .as_ref()
+                .map(|(active, _)| active.name == item.name)
+                .unwrap_or(false)
+        } else {
+            false
+        };
+
+        // If this was the active timer, restart it with new tags
+        if needs_restart {
+            let item = items[index].clone();
+            self.state.stop_timer()?;
+            self.state.start_timer(item)?;
+        }
+
+        self.state.save()?;
+        Ok(())
+    }
+
     fn edit_app_config(&mut self) -> anyhow::Result<()> {
         use crossterm::{
             execute,