minui 0.3.2

//! # Text Widgets
//!
//! A comprehensive collection of text-based UI components for displaying and formatting
//! textual content in terminal applications. This module provides three primary widgets:
//! labels for titles and captions, standalone text widgets for simple content display,
//! and advanced multi-line text blocks with rich formatting capabilities.
//!
//! ## Features
//!
//! - **Multiple text widgets**: Label, Text, and TextBlock for different use cases
//! - **Flexible alignment**: Horizontal and vertical text positioning options
//! - **Advanced wrapping**: Character-level, word-aware, and no-wrap modes
//! - **Rich styling**: Color pairs and formatting options
//! - **Auto-sizing**: Automatic dimension calculation based on content
//! - **Container integration**: Seamless layout within MinUI's container system
//!
//! ## Widget Types
//!
//! ### Label
//! Simple, single-line text for titles, captions, and widget labeling. Ideal for
//! header text, form labels, and UI element identification.
//!
//! ### Text
//! Standalone text display widget for general content. Supports multi-line content
//! with basic alignment and color styling.
//!
//! ### TextBlock
//! Advanced multi-line text widget with sophisticated formatting options including
//! word wrapping, vertical alignment, and precise dimension control.
//!
//! ## Basic Usage
//!
//! ```rust
//! use minui::{Label, Text, TextBlock, Alignment, VerticalAlignment, TextWrapMode, Color};
//!
//! // Simple label for UI elements
//! let title = Label::new("Application Settings")
//!     .with_color(Some(Color::Cyan.into()));
//!
//! // Basic text content
//! let info = Text::new("Welcome to the application!\nPlease configure your preferences.")
//!     .with_alignment(Alignment::Center);
//!
//! // Advanced formatted text block
//! let content = TextBlock::new(40, 10, "Long content that will wrap nicely...")
//!     .with_wrap_mode(TextWrapMode::WrapWords)
//!     .with_vertical_alignment(VerticalAlignment::Middle);
//! ```
//!
//! ## Advanced Text Formatting
//!
//! ```rust
//! use minui::{TextBlock, TextWrapMode, VerticalAlignment, Alignment, ColorPair, Color};
//!
//! // Create a sophisticated text display
//! let formatted_text = TextBlock::new(50, 15,
//!     "This is a comprehensive example of advanced text formatting. \
//!      The text will wrap at word boundaries and be vertically centered \
//!      within the specified dimensions. Color styling enhances readability.")
//!     .with_wrap_mode(TextWrapMode::WrapWords)
//!     .with_vertical_alignment(VerticalAlignment::Middle)
//!     .with_alignment(Alignment::Left)
//!     .with_color(Some(ColorPair::new(Color::White, Color::Blue)));
//! ```
//!
//! ## Layout Integration
//!
//! ```rust
//! use minui::{Container, Label, Text, LayoutDirection};
//!
//! // Combine text widgets in layouts
//! let info_section = Container::new(LayoutDirection::Vertical)
//!     .add_child(Label::new("System Information").with_color(Some(Color::Green.into())))
//!     .add_child(Text::new("CPU: 45% usage\nMemory: 2.1GB / 8GB\nDisk: 250GB free"));
//! ```
//!
//! ## Text Wrapping Modes
//!
//! The TextBlock widget supports three wrapping strategies:
//!
//! - **None**: Content extending beyond width is clipped
//! - **Wrap**: Character-level wrapping at any position
//! - **WrapWords**: Intelligent word-boundary wrapping for readability
//!
//! Text widgets integrate seamlessly with MinUI's container-based layout system,
//! automatically positioning and sizing themselves within parent containers while
//! maintaining proper text formatting and alignment.

use super::Widget;
use crate::input::scroll::Scroller;
use crate::{Color, ColorPair, Result, Window};

/// How to align text horizontally
#[derive(Debug, Clone, Copy)]
pub enum Alignment {
    /// Align text to the left side
    Left,
    /// Center text horizontally
    Center,
    /// Align text to the right side
    Right,
}

/// How to align text vertically
#[derive(Debug, Clone, Copy)]
pub enum VerticalAlignment {
    /// Align text to the top of the widget area
    Top,
    /// Center text vertically within the widget area
    Middle,
    /// Align text to the bottom of the widget area
    Bottom,
}

/// How TextBlock should wrap long lines
#[derive(Debug, Clone, Copy)]
pub enum TextWrapMode {
    /// No text wrapping - content extending beyond width is clipped
    None,
    /// Character-level wrapping - text wraps at any character
    Wrap,
    /// Word-aware wrapping - text wraps at word boundaries
    WrapWords,
}

/// A simple label widget for titles, captions, and labeling other widgets.
///
/// Use this for labeling panels and containers. For standalone text content,
/// use the `Text` widget instead.
pub struct Label {
    /// The label text content
    text: String,
    /// Optional color styling for the text
    colors: Option<ColorPair>,
    /// Horizontal alignment of the text
    alignment: Alignment,
}

impl Label {
    /// Creates a new label with the given text
    pub fn new(text: impl Into<String>) -> Self {
        Self {
            text: text.into(),
            colors: None,
            alignment: Alignment::Left,
        }
    }

    /// Sets foreground and background colors
    pub fn with_color(mut self, colors: ColorPair) -> Self {
        self.colors = Some(colors);
        self
    }

    /// Sets just the text color
    pub fn with_text_color(mut self, color: Color) -> Self {
        self.colors = Some(ColorPair::new(color, Color::Transparent));
        self
    }

    /// Sets how the text is aligned horizontally
    pub fn with_alignment(mut self, alignment: Alignment) -> Self {
        self.alignment = alignment;
        self
    }

    /// Changes the label text
    pub fn set_text(&mut self, text: impl Into<String>) {
        self.text = text.into();
    }

    /// Returns the current text
    pub fn text(&self) -> &str {
        &self.text
    }

    /// Returns the text length in characters
    pub fn get_length(&self) -> u16 {
        self.text.chars().count() as u16
    }

    fn calculate_aligned_x(&self, available_width: u16) -> u16 {
        let text_length = self.get_length();
        match self.alignment {
            Alignment::Left => 0,
            Alignment::Center => {
                if text_length < available_width {
                    (available_width - text_length) / 2
                } else {
                    0
                }
            }
            Alignment::Right => {
                if text_length < available_width {
                    available_width - text_length
                } else {
                    0
                }
            }
        }
    }
}

impl Widget for Label {
    fn draw(&self, window: &mut dyn Window) -> Result<()> {
        let (window_width, _) = window.get_size();
        let x_pos = self.calculate_aligned_x(window_width);

        match self.colors {
            Some(colors) => window.write_str_colored(0, x_pos, &self.text, colors),
            None => window.write_str(0, x_pos, &self.text),
        }
    }

    fn get_size(&self) -> (u16, u16) {
        (self.text.chars().count() as u16, 1)
    }

    fn get_position(&self) -> (u16, u16) {
        (0, 0) // Position is managed by parent container
    }
}

/// A standalone text widget for single-line content.
///
/// Use this for regular text content. Use `Label` for titles and captions.
pub struct Text {
    /// The text content to display
    text: String,
    /// Optional color styling for the text
    colors: Option<ColorPair>,
    /// Horizontal alignment of the text
    alignment: Alignment,
}

impl Text {
    /// Creates a new text widget
    pub fn new(text: impl Into<String>) -> Self {
        Self {
            text: text.into(),
            colors: None,
            alignment: Alignment::Left,
        }
    }

    /// Sets foreground and background colors
    pub fn with_color(mut self, colors: ColorPair) -> Self {
        self.colors = Some(colors);
        self
    }

    /// Sets just the text color
    pub fn with_text_color(mut self, color: Color) -> Self {
        self.colors = Some(ColorPair::new(color, Color::Transparent));
        self
    }

    /// Sets how the text is aligned horizontally
    pub fn with_alignment(mut self, alignment: Alignment) -> Self {
        self.alignment = alignment;
        self
    }

    /// Changes the text content
    pub fn set_text(&mut self, text: impl Into<String>) {
        self.text = text.into();
    }

    /// Returns the current text
    pub fn text(&self) -> &str {
        &self.text
    }

    /// Returns the text length in characters
    pub fn get_length(&self) -> u16 {
        self.text.chars().count() as u16
    }

    fn calculate_aligned_x(&self, available_width: u16) -> u16 {
        let text_length = self.get_length();
        match self.alignment {
            Alignment::Left => 0,
            Alignment::Center => {
                if text_length < available_width {
                    (available_width - text_length) / 2
                } else {
                    0
                }
            }
            Alignment::Right => {
                if text_length < available_width {
                    available_width - text_length
                } else {
                    0
                }
            }
        }
    }
}

impl Widget for Text {
    fn draw(&self, window: &mut dyn Window) -> Result<()> {
        let (available_width, _) = window.get_size();
        let x_pos = self.calculate_aligned_x(available_width);

        match self.colors {
            Some(colors) => window.write_str_colored(0, x_pos, &self.text, colors),
            None => window.write_str(0, x_pos, &self.text),
        }
    }

    fn get_size(&self) -> (u16, u16) {
        (self.text.chars().count() as u16, 1)
    }

    fn get_position(&self) -> (u16, u16) {
        (0, 0) // Position is managed by parent container
    }
}

/// A multi-line text widget with wrapping and scrolling support.
///
/// Use this for longer text content that spans multiple lines.
pub struct TextBlock {
    /// Width of the text display area
    width: u16,
    /// Height of the text display area
    height: u16,
    /// The text content to display
    text: String,
    /// Optional color styling for the text
    colors: Option<ColorPair>,
    /// Text wrapping behavior
    wrap_mode: TextWrapMode,
    /// Horizontal text alignment
    h_align: Alignment,
    /// Vertical text alignment
    v_align: VerticalAlignment,
    /// Scroll state manager for displaying large content
    scroller: Scroller,
    /// Whether to show scroll indicators
    show_scroll_indicators: bool,
}

impl TextBlock {
    /// Creates a new TextBlock with the given size and content
    pub fn new(width: u16, height: u16, text: impl Into<String>) -> Self {
        Self {
            width,
            height,
            text: text.into(),
            colors: None,
            wrap_mode: TextWrapMode::Wrap,
            h_align: Alignment::Left,
            v_align: VerticalAlignment::Top,
            scroller: Scroller::new(),
            show_scroll_indicators: false,
        }
    }

    /// Creates a TextBlock that sizes itself to fit the content
    pub fn auto_sized(text: impl Into<String>) -> Self {
        let text = text.into();
        let lines: Vec<&str> = text.lines().collect();
        let width = lines.iter().map(|line| line.len()).max().unwrap_or(0) as u16;
        let height = lines.len() as u16;

        Self::new(width, height, text)
    }

    /// Creates a TextBlock with word wrapping that sizes itself to fit.
    ///
    /// Wraps text at word boundaries, then sizes the widget to fit the wrapped content.
    pub fn auto_sized_with_word_wrap(text: impl Into<String>, max_width: u16) -> Self {
        let text = text.into();
        let mut lines = Vec::new();
        let mut current_line = String::new();

        for word in text.split_whitespace() {
            let needed_space = if current_line.is_empty() {
                word.len()
            } else {
                current_line.len() + 1 + word.len()
            };

            if needed_space <= max_width as usize {
                if !current_line.is_empty() {
                    current_line.push(' ');
                }
                current_line.push_str(word);
            } else {
                if !current_line.is_empty() {
                    lines.push(current_line);
                }
                current_line = word.to_string();
            }
        }

        if !current_line.is_empty() {
            lines.push(current_line);
        }

        let actual_width = lines.iter().map(|line| line.len()).max().unwrap_or(0) as u16;
        let height = lines.len() as u16;

        let mut text_block = Self::new(actual_width, height, lines.join("\n"));
        text_block.wrap_mode = TextWrapMode::None; // Already wrapped, no need to re-wrap
        text_block
    }

    /// Sets the text colors
    pub fn with_colors(mut self, colors: ColorPair) -> Self {
        self.colors = Some(colors);
        self
    }

    /// Sets just the text color
    pub fn with_text_color(mut self, color: Color) -> Self {
        self.colors = Some(ColorPair::new(color, Color::Transparent));
        self
    }

    /// Sets how text should wrap
    pub fn with_wrap_mode(mut self, mode: TextWrapMode) -> Self {
        self.wrap_mode = mode;
        self
    }

    /// Enables word wrapping
    pub fn with_word_wrap(mut self) -> Self {
        self.wrap_mode = TextWrapMode::WrapWords;
        self
    }

    /// Sets horizontal and vertical alignment
    pub fn with_alignment(mut self, h_align: Alignment, v_align: VerticalAlignment) -> Self {
        self.h_align = h_align;
        self.v_align = v_align;
        self
    }

    /// Enables or disables scroll indicators
    pub fn with_scroll_indicators(mut self, show: bool) -> Self {
        self.show_scroll_indicators = show;
        self
    }

    /// Sets the scroll direction for the text block.
    ///
    /// # Arguments
    /// * `natural` - `true` for natural scrolling (default), `false` for inverted scrolling
    ///
    /// # Examples
    ///
    /// ```rust
    /// use minui::TextBlock;
    ///
    /// let text = TextBlock::new(40, 20, "Some content...")
    ///     .with_scroll_direction(false); // Inverted scrolling
    /// ```
    pub fn with_scroll_direction(mut self, natural: bool) -> Self {
        self.scroller.set_invert_scroll_vertical(!natural);
        self
    }

    /// Sets whether scroll direction is inverted for the text block.
    ///
    /// When enabled, scrolling direction is reversed (e.g., up becomes down).
    pub fn set_invert_scroll(&mut self, invert: bool) {
        self.scroller.set_invert_scroll_vertical(invert);
    }

    /// Returns whether scroll direction is inverted for the text block.
    pub fn is_scroll_inverted(&self) -> bool {
        self.scroller.is_scroll_vertical_inverted()
    }

    /// Scrolls to a specific line
    pub fn scroll_to(&mut self, line: u16) {
        let max_offset = self.max_scroll_offset();
        self.scroller.scroll_to(line, max_offset);
    }

    /// Scrolls by a relative amount (positive = down, negative = up)
    pub fn scroll_by(&mut self, delta: i16) {
        let max_offset = self.max_scroll_offset();
        self.scroller.scroll_by(delta, max_offset);
    }

    /// Scrolls to the top of the content
    pub fn scroll_to_top(&mut self) {
        self.scroller.scroll_to_top();
    }

    /// Scrolls to the bottom of the content
    pub fn scroll_to_bottom(&mut self) {
        let max_offset = self.max_scroll_offset();
        self.scroller.scroll_to_bottom(max_offset);
    }

    /// Returns the current scroll offset
    pub fn scroll_offset(&self) -> u16 {
        self.scroller.offset()
    }

    /// Returns the maximum valid scroll offset
    pub fn max_scroll_offset(&self) -> u16 {
        let lines = self.get_wrapped_lines();
        let total_lines = lines.len() as u16;
        total_lines.saturating_sub(self.height)
    }

    /// Returns whether the content can be scrolled
    pub fn can_scroll(&self) -> bool {
        let lines = self.get_wrapped_lines();
        lines.len() as u16 > self.height
    }

    /// Returns whether scrolling up is possible
    pub fn can_scroll_up(&self) -> bool {
        self.scroller.can_scroll_up()
    }

    /// Returns whether scrolling down is possible
    pub fn can_scroll_down(&self) -> bool {
        self.scroller.can_scroll_down(self.max_scroll_offset())
    }

    /// Handles a mouse scroll event and updates the scroll position
    ///
    /// Returns true if the scroll position changed
    pub fn handle_scroll_event(&mut self, delta: i8) -> bool {
        let max_offset = self.max_scroll_offset();
        self.scroller.handle_scroll_event(delta, max_offset)
    }

    /// Handles a mouse drag event on the TextBlock.
    /// If the drag is on the scrollbar, scrolls to that position.
    /// Returns true if the scroll position changed.
    ///
    /// # Arguments
    /// * `drag_x` - X coordinate of drag relative to TextBlock's top-left
    /// * `drag_y` - Y coordinate of drag relative to TextBlock's top-left
    pub fn handle_drag_event(&mut self, drag_x: u16, drag_y: u16) -> bool {
        if !self.can_scroll() {
            return false;
        }

        let scrollbar_x = self.width.saturating_sub(1);
        let max_scroll = self.max_scroll_offset();

        // Use dedicated drag method for smoother interaction
        self.scroller
            .handle_drag_event(drag_x, drag_y, scrollbar_x, self.height, 0, max_scroll)
    }

    /// Handles a mouse click event on the TextBlock.
    /// If the click is on the scrollbar, scrolls to that position.
    /// Returns true if the scroll position changed.
    ///
    /// # Arguments
    /// * `click_x` - X coordinate of click relative to TextBlock's top-left
    /// * `click_y` - Y coordinate of click relative to TextBlock's top-left
    pub fn handle_click_event(&mut self, click_x: u16, click_y: u16) -> bool {
        if !self.can_scroll() {
            return false;
        }

        let scrollbar_x = self.width.saturating_sub(1);
        let max_scroll = self.max_scroll_offset();

        // Check if click is on scrollbar
        if click_x == scrollbar_x && click_y < self.height {
            return self.scroller.handle_scrollbar_event(
                click_x,
                click_y,
                scrollbar_x,
                self.height,
                0,
                max_scroll,
            );
        }

        false
    }

    /// Returns the number of lines in the wrapped content
    pub fn line_count(&self) -> usize {
        self.get_wrapped_lines().len()
    }

    /// Returns the visible line range as (start, end)
    pub fn visible_range(&self) -> (u16, u16) {
        let start = self.scroller.offset();
        let end = (start + self.height).min(self.line_count() as u16);
        (start, end)
    }

    /// Changes the text content
    pub fn set_text(&mut self, text: impl Into<String>) {
        self.text = text.into();
        // Clamp scroll offset to new content bounds
        let max_offset = self.max_scroll_offset();
        self.scroller.set_offset(self.scroller.offset(), max_offset);
    }

    /// Returns the current text
    pub fn text(&self) -> &str {
        &self.text
    }

    fn get_wrapped_lines(&self) -> Vec<String> {
        match self.wrap_mode {
            TextWrapMode::None => self.text.lines().map(String::from).collect(),
            TextWrapMode::Wrap => self
                .text
                .chars()
                .collect::<Vec<_>>()
                .chunks(self.width as usize)
                .map(|chunk| chunk.iter().collect::<String>())
                .collect(),
            TextWrapMode::WrapWords => {
                let mut lines = Vec::new();
                let mut current_line = String::new();

                for word in self.text.split_whitespace() {
                    if current_line.len() + word.len() + 1 <= self.width as usize {
                        if !current_line.is_empty() {
                            current_line.push(' ');
                        }
                        current_line.push_str(word);
                    } else {
                        if !current_line.is_empty() {
                            lines.push(current_line);
                        }
                        current_line = word.to_string();
                    }
                }

                if !current_line.is_empty() {
                    lines.push(current_line);
                }

                lines
            }
        }
    }
}

impl Widget for TextBlock {
    fn draw(&self, window: &mut dyn Window) -> Result<()> {
        let lines = self.get_wrapped_lines();
        let (window_width, window_height) = window.get_size();

        // Calculate available dimensions (min of widget size and window size)
        let available_width = window_width.min(self.width);
        let available_height = window_height.min(self.height);

        // Calculate starting positions based on alignment
        let total_lines = lines.len().min(available_height as usize);
        let start_y = match self.v_align {
            VerticalAlignment::Top => 0,
            VerticalAlignment::Middle => {
                if total_lines < available_height as usize {
                    (available_height - total_lines as u16) / 2
                } else {
                    0
                }
            }
            VerticalAlignment::Bottom => {
                if total_lines < available_height as usize {
                    available_height - total_lines as u16
                } else {
                    0
                }
            }
        };

        // Get displayable lines with scroll offset
        let start_line = self.scroller.offset() as usize;
        let display_lines: Vec<String> = lines
            .into_iter()
            .skip(start_line)
            .take(available_height as usize)
            .collect();

        // Draw each line
        for (i, line) in display_lines.iter().enumerate() {
            let line_y = start_y + i as u16;
            if line_y >= available_height {
                break;
            }

            let line_x = match self.h_align {
                Alignment::Left => 0,
                Alignment::Center => {
                    if line.len() < available_width as usize {
                        (available_width - line.len() as u16) / 2
                    } else {
                        0
                    }
                }
                Alignment::Right => {
                    if line.len() < available_width as usize {
                        available_width - line.len() as u16
                    } else {
                        0
                    }
                }
            };

            if let Some(colors) = self.colors {
                window.write_str_colored(line_y, line_x, line, colors)?;
            } else {
                window.write_str(line_y, line_x, line)?;
            }
        }

        Ok(())
    }

    fn get_size(&self) -> (u16, u16) {
        (self.width, self.height)
    }

    fn get_position(&self) -> (u16, u16) {
        (0, 0) // Position is managed by parent container
    }
}