turbo_vision/core/

status_data.rs

// (C) 2025 - Enzo Lombardi

//! Status line data structures - declarative status bar building with command-based visibility.
// Borland-compatible status line data structures
// Matches the original Turbo Vision TStatusItem, TStatusDef architecture
//
// This module provides data structures for building status lines in a declarative way,
// matching Borland's approach while being Rust-idiomatic.

use crate::core::command::CommandId;
use crate::core::event::KeyCode;

/// Status line item - displays text and responds to keyboard shortcuts
///
/// Matches Borland: `TStatusItem`
///
/// In Borland, `TStatusItem` is a linked list node with a `next` pointer.
/// In Rust, we use Vec for type safety, but provide builder methods
/// that match Borland's ergonomics.
#[derive(Clone, Debug)]
pub struct StatusItem {
    /// Display text (use ~x~ to mark accelerator key)
    pub text: String,
    /// Keyboard shortcut
    pub key_code: KeyCode,
    /// Command to execute when clicked or shortcut pressed
    pub command: CommandId,
}

impl StatusItem {
    pub fn get_accelerator(&self) -> Option<char> {
        let mut chars = self.text.chars();
        while let Some(ch) = chars.next() {
            if ch == '~' {
                // Next char is the accelerator
                if let Some(accel) = chars.next() {
                    return Some(accel.to_ascii_lowercase());
                }
            }
        }
        None
    }
}

/// Builder for creating status items with a fluent API.
///
/// # Examples
///
/// ```ignore
/// use turbo_vision::core::status_data::StatusItemBuilder;
///
/// let item = StatusItemBuilder::new()
///     .text("~F1~ Help")
///     .key_code(0x3B00)
///     .command(100)
///     .build();
/// ```
pub struct StatusItemBuilder {
    text: Option<String>,
    key_code: KeyCode,
    command: CommandId,
}

impl StatusItemBuilder {
    /// Creates a new `StatusItemBuilder` with default values.
    pub fn new() -> Self {
        Self {
            text: None,
            key_code: 0,
            command: 0,
        }
    }

    /// Sets the status item text (required).
    /// Use ~x~ to mark the accelerator key.
    #[must_use]
    pub fn text(mut self, text: impl Into<String>) -> Self {
        self.text = Some(text.into());
        self
    }

    /// Sets the keyboard shortcut key code.
    #[must_use]
    pub fn key_code(mut self, key_code: KeyCode) -> Self {
        self.key_code = key_code;
        self
    }

    /// Binds the item to a key chord such as `"Alt+X"` or `"F10"`.
    ///
    /// # Panics
    ///
    /// Panics on a chord `parse_key_chord` does not understand.
    #[must_use]
    pub fn key(mut self, chord: &str) -> Self {
        self.key_code = crate::core::menu_data::key_code_for_chord(chord);
        self
    }

    /// Sets the command to execute.
    #[must_use]
    pub fn command(mut self, command: CommandId) -> Self {
        self.command = command;
        self
    }

    /// Builds the `StatusItem`.
    ///
    /// # Panics
    ///
    /// Panics if required fields (text) are not set.
    pub fn build(self) -> StatusItem {
        let text = self.text.expect("StatusItem text must be set");
        StatusItem {
            text,
            key_code: self.key_code,
            command: self.command,
        }
    }
}

impl Default for StatusItemBuilder {
    fn default() -> Self {
        Self::new()
    }
}

/// Status line definition - defines which items are visible for a command set range
///
/// Matches Borland: `TStatusDef`
///
/// In Borland, `TStatusDef` is a linked list node with:
/// - `min`, `max`: command range for which this def is active
/// - `items`: pointer to first item in linked list
/// - `next`: pointer to next status def
///
/// In Rust, we use Vec for type safety and provide convenient builders.
#[derive(Clone, Debug)]
pub struct StatusDef {
    /// Minimum command ID for which this definition is active
    pub min: u16,
    /// Maximum command ID for which this definition is active
    pub max: u16,
    /// Status items to display
    pub items: Vec<StatusItem>,
}

impl StatusDef {
    /// Create a new status definition
    ///
    /// Matches Borland: `TStatusDef(min, max, items)`
    ///
    /// # Example
    /// ```ignore
    /// let def = StatusDef::new(0, 0xFFFF, vec![
    ///     StatusItemBuilder::new().text("~F1~ Help").key("F1").command(CM_HELP).build(),
    ///     StatusItemBuilder::new().text("~Alt+X~ Exit").key("Alt+X").command(CM_QUIT).build(),
    /// ]);
    /// ```
    pub fn new(min: u16, max: u16, items: Vec<StatusItem>) -> Self {
        Self { min, max, items }
    }

    /// Create a status definition for all command ranges (default)
    ///
    /// Matches Borland: `TStatusDef(0, 0xFFFF, items)`
    pub fn default_range(items: Vec<StatusItem>) -> Self {
        Self {
            min: 0,
            max: 0xFFFF,
            items,
        }
    }

    /// Check if this definition applies to the given command set
    ///
    /// In Borland, the status line checks which definition's range
    /// matches the currently focused view's command set.
    pub fn applies_to(&self, command_set: u16) -> bool {
        command_set >= self.min && command_set <= self.max
    }

    /// Add an item to this definition
    pub fn add(&mut self, item: StatusItem) {
        self.items.push(item);
    }

    /// Get the number of items
    pub fn len(&self) -> usize {
        self.items.len()
    }

    /// Check if definition has no items
    pub fn is_empty(&self) -> bool {
        self.items.is_empty()
    }
}

/// Builder for creating status definitions with a fluent API.
///
/// # Examples
///
/// ```ignore
/// use turbo_vision::core::status_data::{StatusDefBuilder, StatusItem};
///
/// let def = StatusDefBuilder::new()
///     .range(0, 100)
///     .add_item(StatusItemBuilder::new().text("~F1~ Help").key_code(0x3B00).command(100).build())
///     .add_item(StatusItemBuilder::new().text("~F2~ Save").key_code(0x3C00).command(101).build())
///     .build();
/// ```
pub struct StatusDefBuilder {
    min: u16,
    max: u16,
    items: Vec<StatusItem>,
}

impl StatusDefBuilder {
    /// Creates a new `StatusDefBuilder` with default values (full range: 0-0xFFFF).
    pub fn new() -> Self {
        Self {
            min: 0,
            max: 0xFFFF,
            items: Vec::new(),
        }
    }

    /// Sets the command range (default: 0-0xFFFF).
    #[must_use]
    pub fn range(mut self, min: u16, max: u16) -> Self {
        self.min = min;
        self.max = max;
        self
    }

    /// Sets the minimum command ID.
    #[must_use]
    pub fn min(mut self, min: u16) -> Self {
        self.min = min;
        self
    }

    /// Sets the maximum command ID.
    #[must_use]
    pub fn max(mut self, max: u16) -> Self {
        self.max = max;
        self
    }

    /// Adds a status item to the definition.
    #[must_use]
    pub fn add_item(mut self, item: StatusItem) -> Self {
        self.items.push(item);
        self
    }

    /// Sets all items at once.
    #[must_use]
    pub fn items(mut self, items: Vec<StatusItem>) -> Self {
        self.items = items;
        self
    }

    /// Builds the `StatusDef`.
    pub fn build(self) -> StatusDef {
        StatusDef {
            min: self.min,
            max: self.max,
            items: self.items,
        }
    }
}

impl Default for StatusDefBuilder {
    fn default() -> Self {
        Self::new()
    }
}

/// Status line configuration - collection of status definitions
///
/// Matches Borland: linked list of `TStatusDef`
///
/// In Borland, status defs are linked via `next` pointers.
/// In Rust, we use Vec for type safety.
#[derive(Clone, Debug)]
pub struct StatusLine {
    /// Status definitions (evaluated in order)
    pub defs: Vec<StatusDef>,
}

impl StatusLine {
    /// Create a new status line configuration
    pub fn new(defs: Vec<StatusDef>) -> Self {
        Self { defs }
    }

    /// Create a status line with a single default definition
    pub fn single(items: Vec<StatusItem>) -> Self {
        Self {
            defs: vec![StatusDef::default_range(items)],
        }
    }

    /// Get the status definition that applies to the given command set
    ///
    /// Matches Borland: `TStatusLine::update()` logic
    pub fn get_def_for(&self, command_set: u16) -> Option<&StatusDef> {
        // Return first matching definition (Borland behavior)
        self.defs.iter().find(|def| def.applies_to(command_set))
    }

    /// Add a status definition
    pub fn add_def(&mut self, def: StatusDef) {
        self.defs.push(def);
    }
}

/// Builder for constructing status line configurations fluently
///
/// This provides a Borland-style builder API while being Rust-idiomatic.
///
/// # Example (Borland-style)
/// ```ignore
/// let status = StatusLineBuilder::new()
///     .add_def(0, 0xFFFF, vec![
///         StatusItemBuilder::new().text("~F1~ Help").key("F1").command(CM_HELP).build(),
///         StatusItemBuilder::new().text("~Alt+X~ Exit").key("Alt+X").command(CM_QUIT).build(),
///     ])
///     .build();
/// ```
pub struct StatusLineBuilder {
    defs: Vec<StatusDef>,
}

impl StatusLineBuilder {
    /// Create a new status line builder
    pub fn new() -> Self {
        Self { defs: Vec::new() }
    }

    /// Add a status definition with command range
    ///
    /// Matches Borland: `TStatusDef(min, max, items)`
    pub fn add_def(mut self, min: u16, max: u16, items: Vec<StatusItem>) -> Self {
        self.defs.push(StatusDef::new(min, max, items));
        self
    }

    /// Add a default status definition (applies to all command sets)
    pub fn add_default_def(mut self, items: Vec<StatusItem>) -> Self {
        self.defs.push(StatusDef::default_range(items));
        self
    }

    /// Build the status line configuration
    pub fn build(self) -> StatusLine {
        StatusLine::new(self.defs)
    }
}

impl Default for StatusLineBuilder {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_status_def() {
        let def = StatusDef::new(
            0,
            100,
            vec![
                StatusItemBuilder::new()
                    .text("~F1~ Help")
                    .key_code(0x3B00)
                    .command(100)
                    .build(),
                StatusItemBuilder::new()
                    .text("~Alt+X~ Exit")
                    .key("Alt+X")
                    .command(101)
                    .build(),
            ],
        );

        assert!(def.applies_to(50));
        assert!(def.applies_to(0));
        assert!(def.applies_to(100));
        assert!(!def.applies_to(101));
        assert_eq!(def.len(), 2);
    }

    #[test]
    fn test_status_line_builder() {
        let status = StatusLineBuilder::new()
            .add_def(
                0,
                100,
                vec![
                    StatusItemBuilder::new()
                        .text("~F1~ Help")
                        .key_code(0x3B00)
                        .command(100)
                        .build(),
                    StatusItemBuilder::new()
                        .text("~F2~ Save")
                        .key_code(0x3C00)
                        .command(101)
                        .build(),
                ],
            )
            .add_def(
                101,
                200,
                vec![
                    StatusItemBuilder::new()
                        .text("~F1~ Help")
                        .key_code(0x3B00)
                        .command(100)
                        .build(),
                    StatusItemBuilder::new()
                        .text("~Esc~ Cancel")
                        .key_code(0x011B)
                        .command(102)
                        .build(),
                ],
            )
            .build();

        assert_eq!(status.defs.len(), 2);

        let def1 = status.get_def_for(50);
        assert!(def1.is_some());
        assert_eq!(def1.unwrap().len(), 2);

        let def2 = status.get_def_for(150);
        assert!(def2.is_some());
        assert_eq!(def2.unwrap().len(), 2);
    }

    #[test]
    fn test_accelerator() {
        let item = StatusItemBuilder::new()
            .text("~F1~ Help")
            .key_code(0x3B00)
            .command(100)
            .build();
        assert_eq!(item.get_accelerator(), Some('f'));
    }
}