canvas library usage instead of internal canvas on the form, others are still using canvas from state. Needed debugging because its not working yet

client/src/state/pages/form.rs

@@ -2,7 +2,7 @@
 
 use crate::config::colors::themes::Theme;
 use crate::state::app::highlight::HighlightState;
-use crate::state::pages::canvas_state::CanvasState;
+use canvas::{CanvasState, CanvasAction, ActionContext}; // CHANGED: Use canvas crate
 use common::proto::komp_ac::search::search_response::Hit;
 use ratatui::layout::Rect;
 use ratatui::Frame;
@@ -146,7 +146,7 @@ impl FormState {
         } else {
             self.current_position = 1;
         }
-        self.deactivate_autocomplete();
+        self.deactivate_suggestions(); // CHANGED: Use canvas trait method
         self.link_display_map.clear();
     }
 
@@ -205,14 +205,25 @@ impl FormState {
         self.has_unsaved_changes = false;
         self.current_field = 0;
         self.current_cursor_pos = 0;
-        self.deactivate_autocomplete();
+        self.deactivate_suggestions(); // CHANGED: Use canvas trait method
         self.link_display_map.clear();
     }
 
-    pub fn deactivate_autocomplete(&mut self) {
-        self.autocomplete_active = false;
-        self.autocomplete_suggestions.clear();
-        self.selected_suggestion_index = None;
+    // REMOVED: deactivate_autocomplete() - now using trait method
+
+    // NEW: Keep the rich suggestions methods for compatibility
+    pub fn get_rich_suggestions(&self) -> Option<&[Hit]> {
+        if self.autocomplete_active {
+            Some(&self.autocomplete_suggestions)
+        } else {
+            None
+        }
+    }
+
+    pub fn activate_rich_suggestions(&mut self, suggestions: Vec<Hit>) {
+        self.autocomplete_suggestions = suggestions;
+        self.autocomplete_active = !self.autocomplete_suggestions.is_empty();
+        self.selected_suggestion_index = if self.autocomplete_active { Some(0) } else { None };
         self.autocomplete_loading = false;
     }
 }
@@ -221,49 +232,54 @@ impl CanvasState for FormState {
     fn current_field(&self) -> usize {
         self.current_field
     }
+    
     fn current_cursor_pos(&self) -> usize {
         self.current_cursor_pos
     }
+    
     fn has_unsaved_changes(&self) -> bool {
         self.has_unsaved_changes
     }
+    
     fn inputs(&self) -> Vec<&String> {
         self.values.iter().collect()
     }
+    
     fn get_current_input(&self) -> &str {
         FormState::get_current_input(self)
     }
+    
     fn get_current_input_mut(&mut self) -> &mut String {
         FormState::get_current_input_mut(self)
     }
+    
     fn fields(&self) -> Vec<&str> {
         self.fields
             .iter()
             .map(|f| f.display_name.as_str())
             .collect()
     }
+    
     fn set_current_field(&mut self, index: usize) {
         if index < self.fields.len() {
             self.current_field = index;
         }
-        self.deactivate_autocomplete();
+        self.deactivate_suggestions(); // CHANGED: Use canvas trait method
     }
+    
     fn set_current_cursor_pos(&mut self, pos: usize) {
         self.current_cursor_pos = pos;
     }
+    
     fn set_has_unsaved_changes(&mut self, changed: bool) {
         self.has_unsaved_changes = changed;
     }
+
+    // --- CANVAS CRATE SUGGESTIONS SUPPORT ---
     fn get_suggestions(&self) -> Option<&[String]> {
-        None
-    }
-    fn get_rich_suggestions(&self) -> Option<&[Hit]> {
-        if self.autocomplete_active {
-            Some(&self.autocomplete_suggestions)
-        } else {
-            None
-        }
+        None // We use rich suggestions instead
     }
+
     fn get_selected_suggestion_index(&self) -> Option<usize> {
         if self.autocomplete_active {
             self.selected_suggestion_index
@@ -272,6 +288,52 @@ impl CanvasState for FormState {
         }
     }
 
+    fn set_selected_suggestion_index(&mut self, index: Option<usize>) {
+        if self.autocomplete_active {
+            self.selected_suggestion_index = index;
+        }
+    }
+
+    fn activate_suggestions(&mut self, suggestions: Vec<String>) {
+        // For compatibility - convert to rich format if needed
+        self.autocomplete_active = true;
+        self.selected_suggestion_index = if suggestions.is_empty() { None } else { Some(0) };
+    }
+
+    fn deactivate_suggestions(&mut self) {
+        self.autocomplete_active = false;
+        self.autocomplete_suggestions.clear();
+        self.selected_suggestion_index = None;
+        self.autocomplete_loading = false;
+    }
+
+    // --- FEATURE-SPECIFIC ACTION HANDLING ---
+    fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        match action {
+            CanvasAction::SelectSuggestion => {
+                if let Some(selected_idx) = self.selected_suggestion_index {
+                    if let Some(hit) = self.autocomplete_suggestions.get(selected_idx).cloned() { // ADD .cloned()
+                        // Extract the value from the selected suggestion
+                        if let Ok(content_map) = serde_json::from_str::<HashMap<String, serde_json::Value>>(&hit.content_json) {
+                            let current_field_def = &self.fields[self.current_field];
+                            if let Some(value) = content_map.get(&current_field_def.data_key) {
+                                let new_value = json_value_to_string(value);
+                                let display_name = self.get_display_name_for_hit(&hit); // Calculate first
+                                *self.get_current_input_mut() = new_value.clone();
+                                self.set_current_cursor_pos(new_value.len());
+                                self.set_has_unsaved_changes(true);
+                                self.deactivate_suggestions();
+                                return Some(format!("Selected: {}", display_name)); // Use calculated value
+                            }
+                        }
+                    }
+                }
+                None
+            }
+            _ => None, // Let canvas handle other actions
+        }
+    }
+
     fn get_display_value_for_field(&self, index: usize) -> &str {
         if let Some(display_text) = self.link_display_map.get(&index) {
             return display_text.as_str();
@@ -282,7 +344,6 @@ impl CanvasState for FormState {
             .unwrap_or("")
     }
 
-    // --- IMPLEMENT THE NEW TRAIT METHOD ---
     fn has_display_override(&self, index: usize) -> bool {
         self.link_display_map.contains_key(&index)
     }