seems like proper split between event.rs and read_only.rs

2025-02-28 11:00:04 +01:00
parent 3c4957b75b
commit c6039df819
5 changed files with 567 additions and 522 deletions
--- a/client/src/modes/handlers/read_only.rs
+++ b/client/src/modes/handlers/read_only.rs
@@ -0,0 +1,422 @@
+// src/modes/handlers/read_only.rs
+
+use crossterm::event::{KeyEvent, KeyCode};
+use crate::config::config::Config;
+use crate::ui::handlers::form::FormState;
+use crate::config::key_sequences::KeySequenceTracker;
+use crate::tui::terminal::AppTerminal;
+
+#[derive(PartialEq)]
+enum CharType {
+    Whitespace,
+    Alphanumeric,
+    Punctuation,
+}
+
+pub async fn handle_read_only_event(
+    key: KeyEvent,
+    config: &Config,
+    form_state: &mut FormState,
+    key_sequence_tracker: &mut KeySequenceTracker,
+    current_position: &mut u64,
+    total_count: u64,
+    app_terminal: &mut AppTerminal,
+    command_message: &mut String,
+    edit_mode_cooldown: &mut bool,
+    ideal_cursor_column: &mut usize,
+) -> Result<(bool, String), Box<dyn std::error::Error>> {
+    // Handle navigation between entries
+    match key.code {
+        KeyCode::Left => {
+            let new_position = current_position.saturating_sub(1);
+            if new_position >= 1 {
+                *current_position = new_position;
+                match app_terminal.get_adresar_by_position(*current_position).await {
+                    Ok(response) => {
+                        form_state.id = response.id;
+                        form_state.values = vec![
+                            response.firma, response.kz, response.drc,
+                            response.ulica, response.psc, response.mesto,
+                            response.stat, response.banka, response.ucet,
+                            response.skladm, response.ico, response.kontakt,
+                            response.telefon, response.skladu, response.fax,
+                        ];
+                        let current_input = form_state.get_current_input();
+                        let max_cursor_pos = if !current_input.is_empty() {
+                            current_input.len() - 1
+                        } else { 0 };
+                        // Fix type mismatch by dereferencing and using std::cmp::min
+                        form_state.current_cursor_pos = std::cmp::min(*ideal_cursor_column, max_cursor_pos);
+                        form_state.has_unsaved_changes = false;
+                        *command_message = format!("Loaded entry {}", *current_position);
+                    }
+                    Err(e) => {
+                        *command_message = format!("Error loading entry: {}", e);
+                    }
+                }
+                key_sequence_tracker.reset();
+            }
+            return Ok((false, command_message.clone()));
+        }
+        KeyCode::Right => {
+            if *current_position <= total_count {
+                *current_position += 1;
+                if *current_position <= total_count {
+                    match app_terminal.get_adresar_by_position(*current_position).await {
+                        Ok(response) => {
+                            form_state.id = response.id;
+                            form_state.values = vec![
+                                response.firma, response.kz, response.drc,
+                                response.ulica, response.psc, response.mesto,
+                                response.stat, response.banka, response.ucet,
+                                response.skladm, response.ico, response.kontakt,
+                                response.telefon, response.skladu, response.fax,
+                            ];
+                            let current_input = form_state.get_current_input();
+                            let max_cursor_pos = if !current_input.is_empty() {
+                                current_input.len() - 1
+                            } else { 0 };
+                            // Fix type mismatch
+                            form_state.current_cursor_pos = std::cmp::min(*ideal_cursor_column, max_cursor_pos);
+                            form_state.has_unsaved_changes = false;
+                            *command_message = format!("Loaded entry {}", *current_position);
+                        }
+                        Err(e) => {
+                            *command_message = format!("Error loading entry: {}", e);
+                        }
+                    }
+                } else {
+                    form_state.reset_to_empty();
+                    form_state.current_field = 0;
+                    form_state.current_cursor_pos = 0;
+                    *ideal_cursor_column = 0; // Reset ideal column as well
+                    *command_message = "New entry mode".to_string();
+                }
+                key_sequence_tracker.reset();
+            }
+            return Ok((false, command_message.clone()));
+        }
+        KeyCode::Esc => {
+            // Reset key sequence tracker and message on Escape
+            key_sequence_tracker.reset();
+            *command_message = "".to_string();
+            return Ok((false, "".to_string()));
+        }
+        _ => {}
+    }
+
+    // Handle key sequences and actions
+    if let KeyCode::Char(_) = key.code {
+        if key.modifiers.is_empty() {
+            key_sequence_tracker.add_key(key.code);
+            let sequence = key_sequence_tracker.get_sequence();
+            let sequence_str = key_sequence_tracker.sequence_to_string();
+
+            if let Some(action) = config.matches_key_sequence(&sequence) {
+                let result = execute_action(action, form_state, ideal_cursor_column)?;
+                key_sequence_tracker.reset();
+                return Ok((false, result));
+            }
+
+            if sequence.len() == 1 {
+                let is_prefix = is_prefix_of_multikey_binding(&sequence_str, config);
+                if !is_prefix {
+                    if let Some(action) = config.get_action_for_key(key.code, key.modifiers) {
+                        let result = execute_action(action, form_state, ideal_cursor_column)?;
+                        key_sequence_tracker.reset();
+                        return Ok((false, result));
+                    }
+                }
+            }
+        } else {
+            key_sequence_tracker.reset();
+        }
+    } else {
+        key_sequence_tracker.reset();
+
+        // Provide feedback when not in edit mode and cooldown expired
+        if !*edit_mode_cooldown {
+            let default_key = "i".to_string();
+            let edit_key = config.keybindings.get("enter_edit_mode")
+                .and_then(|keys| keys.first())
+                .unwrap_or(&default_key);
+            *command_message = format!("Read-only mode - press {} to edit", edit_key);
+        }
+    }
+
+    Ok((false, command_message.clone()))
+}
+
+fn execute_action(
+    action: &str,
+    form_state: &mut FormState,
+    ideal_cursor_column: &mut usize,
+) -> Result<String, Box<dyn std::error::Error>> {
+    let current_input = form_state.get_current_input();
+    let current_pos = form_state.current_cursor_pos;
+
+    match action {
+        "move_left" => {
+            form_state.current_cursor_pos = current_pos.saturating_sub(1);
+            *ideal_cursor_column = form_state.current_cursor_pos; // Update ideal column
+            Ok("".to_string())
+        }
+        "move_right" => {
+            if !current_input.is_empty() && current_pos < current_input.len() - 1 {
+                form_state.current_cursor_pos += 1;
+                *ideal_cursor_column = form_state.current_cursor_pos; // Update ideal column
+            }
+            Ok("".to_string())
+        }
+        "move_word_next" => {
+            if !current_input.is_empty() {
+                let new_pos = find_next_word_start(current_input, current_pos);
+                form_state.current_cursor_pos = new_pos.min(current_input.len().saturating_sub(1));
+                *ideal_cursor_column = form_state.current_cursor_pos; // Update ideal column
+            }
+            Ok("".to_string())
+        }
+        "move_word_end" => {
+            if !current_input.is_empty() {
+                let new_pos = find_word_end(current_input, current_pos);
+                form_state.current_cursor_pos = new_pos.min(current_input.len().saturating_sub(1));
+                *ideal_cursor_column = form_state.current_cursor_pos; // Update ideal column
+            }
+            Ok("".to_string())
+        }
+        "move_word_prev" => {
+            if !current_input.is_empty() {
+                let new_pos = find_prev_word_start(current_input, current_pos);
+                form_state.current_cursor_pos = new_pos;
+                *ideal_cursor_column = form_state.current_cursor_pos; // Update ideal column
+            }
+            Ok("".to_string())
+        }
+        "move_word_end_prev" => {
+            if !current_input.is_empty() {
+                let new_pos = find_prev_word_end(current_input, current_pos);
+                form_state.current_cursor_pos = new_pos;
+                *ideal_cursor_column = form_state.current_cursor_pos; // Update ideal column
+            }
+            Ok("Moved to previous word end".to_string())
+        }
+        "move_line_start" => {
+            form_state.current_cursor_pos = 0;
+            *ideal_cursor_column = form_state.current_cursor_pos; // Update ideal column
+            Ok("".to_string())
+        }
+        "move_line_end" => {
+            if !current_input.is_empty() {
+                form_state.current_cursor_pos = current_input.len() - 1;
+                *ideal_cursor_column = form_state.current_cursor_pos; // Update ideal column
+            }
+            Ok("".to_string())
+        }
+        "move_up" => {
+            // Change field first
+            if form_state.current_field == 0 {
+                form_state.current_field = form_state.fields.len() - 1;
+            } else {
+                form_state.current_field = form_state.current_field.saturating_sub(1);
+            }
+
+            // Get current input AFTER changing field
+            let current_input = form_state.get_current_input();
+            let max_cursor_pos = if !current_input.is_empty() {
+                current_input.len() - 1
+            } else {
+                0
+            };
+            // Fix type mismatch
+            form_state.current_cursor_pos = std::cmp::min(*ideal_cursor_column, max_cursor_pos);
+            Ok("".to_string())
+        }
+        "move_down" => {
+            // Change field first
+            form_state.current_field = (form_state.current_field + 1) % form_state.fields.len();
+
+            // Get current input AFTER changing field
+            let current_input = form_state.get_current_input();
+            let max_cursor_pos = if !current_input.is_empty() {
+                current_input.len() - 1
+            } else {
+                0
+            };
+            // Fix type mismatch
+            form_state.current_cursor_pos = std::cmp::min(*ideal_cursor_column, max_cursor_pos);
+            Ok("".to_string())
+        }
+        "move_first_line" => {
+            // Change field first
+            form_state.current_field = 0;
+
+            // Get current input AFTER changing field
+            let current_input = form_state.get_current_input();
+            let max_cursor_pos = if !current_input.is_empty() {
+                current_input.len() - 1
+            } else {
+                0
+            };
+            // Fix type mismatch
+            form_state.current_cursor_pos = std::cmp::min(*ideal_cursor_column, max_cursor_pos);
+            Ok("Moved to first line".to_string())
+        }
+        "move_last_line" => {
+            // Change field first
+            form_state.current_field = form_state.fields.len() - 1;
+
+            // Get current input AFTER changing field
+            let current_input = form_state.get_current_input();
+            let max_cursor_pos = if !current_input.is_empty() {
+                current_input.len() - 1
+            } else {
+                0
+            };
+            // Fix type mismatch
+            form_state.current_cursor_pos = std::cmp::min(*ideal_cursor_column, max_cursor_pos);
+            Ok("Moved to last line".to_string())
+        }
+        _ => Ok("Unknown action".to_string()),
+    }
+}
+
+fn is_prefix_of_multikey_binding(sequence: &str, config: &Config) -> bool {
+    for (_, bindings) in &config.keybindings {
+        for binding in bindings {
+            if binding.contains('+') { continue; }
+            if binding.len() > sequence.len() && binding.starts_with(sequence) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn get_char_type(c: char) -> CharType {
+    if c.is_whitespace() {
+        CharType::Whitespace
+    } else if c.is_alphanumeric() {
+        CharType::Alphanumeric
+    } else {
+        CharType::Punctuation
+    }
+}
+
+fn find_next_word_start(text: &str, current_pos: usize) -> usize {
+    let chars: Vec<char> = text.chars().collect();
+    if chars.is_empty() || current_pos >= chars.len() {
+        return current_pos;
+    }
+
+    let mut pos = current_pos;
+    let initial_type = get_char_type(chars[pos]);
+    while pos < chars.len() && get_char_type(chars[pos]) == initial_type {
+        pos += 1;
+    }
+
+    while pos < chars.len() && get_char_type(chars[pos]) == CharType::Whitespace {
+        pos += 1;
+    }
+
+    pos
+}
+
+fn find_word_end(text: &str, current_pos: usize) -> usize {
+    let chars: Vec<char> = text.chars().collect();
+    if chars.is_empty() {
+        return 0;
+    }
+
+    if current_pos >= chars.len() - 1 {
+        return chars.len() - 1;
+    }
+
+    let mut pos = current_pos;
+
+    if get_char_type(chars[pos]) == CharType::Whitespace {
+        while pos < chars.len() && get_char_type(chars[pos]) == CharType::Whitespace {
+            pos += 1;
+        }
+    } else {
+        let current_type = get_char_type(chars[pos]);
+        if pos + 1 < chars.len() && get_char_type(chars[pos + 1]) != current_type {
+            pos += 1;
+            while pos < chars.len() && get_char_type(chars[pos]) == CharType::Whitespace {
+                pos += 1;
+            }
+        }
+    }
+
+    if pos >= chars.len() {
+        return chars.len() - 1;
+    }
+
+    let word_type = get_char_type(chars[pos]);
+    while pos + 1 < chars.len() && get_char_type(chars[pos + 1]) == word_type {
+        pos += 1;
+    }
+
+    pos
+}
+
+fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
+    let chars: Vec<char> = text.chars().collect();
+    if chars.is_empty() || current_pos == 0 {
+        return 0;
+    }
+
+    let mut pos = current_pos.saturating_sub(1);
+
+    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
+        pos -= 1;
+    }
+
+    if get_char_type(chars[pos]) != CharType::Whitespace {
+        let word_type = get_char_type(chars[pos]);
+        while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
+            pos -= 1;
+        }
+    }
+
+    pos
+}
+
+fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
+    let chars: Vec<char> = text.chars().collect();
+    if chars.is_empty() || current_pos <= 1 {
+        return 0;
+    }
+
+    let mut pos = current_pos.saturating_sub(1);
+
+    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
+        pos -= 1;
+    }
+
+    if pos > 0 && get_char_type(chars[pos]) != CharType::Whitespace {
+        let word_type = get_char_type(chars[pos]);
+
+        while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
+            pos -= 1;
+        }
+
+        while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
+            pos -= 1;
+        }
+
+        if pos > 0 {
+            pos -= 1;
+            let prev_word_type = get_char_type(chars[pos]);
+            while pos > 0 && get_char_type(chars[pos - 1]) == prev_word_type {
+                pos -= 1;
+            }
+
+            while pos < chars.len() - 1 &&
+                  get_char_type(chars[pos + 1]) == prev_word_type {
+                pos += 1;
+            }
+        }
+    }
+
+    pos
+}