rnk 0.19.3

//! Color Picker component for selecting colors
//!
//! Provides a color picker UI for terminal applications.
//!
//! # Example
//!
//! ```rust,ignore
//! use rnk::prelude::*;
//! use rnk::components::ColorPicker;
//!
//! fn app() -> Element {
//!     let picker = ColorPicker::new()
//!         .selected(Color::Blue);
//!
//!     picker.into_element()
//! }
//! ```

use crate::components::{Box, InteractionMode, InteractionOutcome, Text};
use crate::core::{AccessibilityProps, AccessibilityRole, Color, Element, FlexDirection};

/// Predefined color palette
#[derive(Debug, Clone)]
pub struct ColorPalette {
    /// Colors in the palette
    pub colors: Vec<Color>,
    /// Palette name
    pub name: String,
}

impl ColorPalette {
    /// Create a new palette
    pub fn new(name: impl Into<String>, colors: Vec<Color>) -> Self {
        Self {
            name: name.into(),
            colors,
        }
    }

    /// Basic 16 ANSI colors
    pub fn basic() -> Self {
        Self::new(
            "Basic",
            vec![
                Color::Black,
                Color::Red,
                Color::Green,
                Color::Yellow,
                Color::Blue,
                Color::Magenta,
                Color::Cyan,
                Color::White,
                Color::BrightBlack,
                Color::BrightRed,
                Color::BrightGreen,
                Color::BrightYellow,
                Color::BrightBlue,
                Color::BrightMagenta,
                Color::BrightCyan,
                Color::BrightWhite,
            ],
        )
    }

    /// Grayscale palette
    pub fn grayscale() -> Self {
        let colors: Vec<Color> = (0..24)
            .map(|i| {
                let gray = 8 + i * 10;
                Color::Rgb(gray, gray, gray)
            })
            .collect();
        Self::new("Grayscale", colors)
    }

    /// Rainbow palette
    pub fn rainbow() -> Self {
        Self::new(
            "Rainbow",
            vec![
                Color::Rgb(255, 0, 0),   // Red
                Color::Rgb(255, 127, 0), // Orange
                Color::Rgb(255, 255, 0), // Yellow
                Color::Rgb(0, 255, 0),   // Green
                Color::Rgb(0, 255, 255), // Cyan
                Color::Rgb(0, 0, 255),   // Blue
                Color::Rgb(127, 0, 255), // Purple
                Color::Rgb(255, 0, 255), // Magenta
            ],
        )
    }

    /// Pastel palette
    pub fn pastel() -> Self {
        Self::new(
            "Pastel",
            vec![
                Color::Rgb(255, 179, 186), // Pink
                Color::Rgb(255, 223, 186), // Peach
                Color::Rgb(255, 255, 186), // Yellow
                Color::Rgb(186, 255, 201), // Mint
                Color::Rgb(186, 225, 255), // Sky
                Color::Rgb(218, 186, 255), // Lavender
            ],
        )
    }

    /// Material design colors
    pub fn material() -> Self {
        Self::new(
            "Material",
            vec![
                Color::Rgb(244, 67, 54),  // Red
                Color::Rgb(233, 30, 99),  // Pink
                Color::Rgb(156, 39, 176), // Purple
                Color::Rgb(103, 58, 183), // Deep Purple
                Color::Rgb(63, 81, 181),  // Indigo
                Color::Rgb(33, 150, 243), // Blue
                Color::Rgb(3, 169, 244),  // Light Blue
                Color::Rgb(0, 188, 212),  // Cyan
                Color::Rgb(0, 150, 136),  // Teal
                Color::Rgb(76, 175, 80),  // Green
                Color::Rgb(139, 195, 74), // Light Green
                Color::Rgb(205, 220, 57), // Lime
                Color::Rgb(255, 235, 59), // Yellow
                Color::Rgb(255, 193, 7),  // Amber
                Color::Rgb(255, 152, 0),  // Orange
                Color::Rgb(255, 87, 34),  // Deep Orange
            ],
        )
    }
}

impl Default for ColorPalette {
    fn default() -> Self {
        Self::basic()
    }
}

/// Color picker state
#[derive(Debug, Clone, Default)]
pub struct ColorPickerState {
    /// Selected color index
    pub selected: usize,
    /// Whether the picker is open
    pub open: bool,
}

impl ColorPickerState {
    /// Create a new state
    pub fn new() -> Self {
        Self::default()
    }

    /// Open the picker
    pub fn open(&mut self) {
        self.open = true;
    }

    /// Close the picker
    pub fn close(&mut self) {
        self.open = false;
    }

    /// Toggle the picker
    pub fn toggle(&mut self) {
        self.open = !self.open;
    }

    /// Move selection
    pub fn select(&mut self, index: usize) {
        self.selected = index;
    }

    /// Move selection left
    pub fn select_prev(&mut self, max: usize) {
        if self.selected > 0 {
            self.selected -= 1;
        } else if max > 0 {
            self.selected = max - 1;
        }
    }

    /// Move selection right
    pub fn select_next(&mut self, max: usize) {
        if max > 0 && self.selected < max - 1 {
            self.selected += 1;
        } else {
            self.selected = 0;
        }
    }
}

/// Color picker style
#[derive(Debug, Clone)]
pub struct ColorPickerStyle {
    /// Colors per row
    pub colors_per_row: usize,
    /// Show color names
    pub show_names: bool,
    /// Show hex values
    pub show_hex: bool,
    /// Selection indicator
    pub selection_indicator: String,
    /// Border color
    pub border_color: Color,
}

impl Default for ColorPickerStyle {
    fn default() -> Self {
        Self {
            colors_per_row: 8,
            show_names: false,
            show_hex: false,
            selection_indicator: "▼".to_string(),
            border_color: Color::White,
        }
    }
}

impl ColorPickerStyle {
    /// Create a new style
    pub fn new() -> Self {
        Self::default()
    }

    /// Set colors per row
    pub fn colors_per_row(mut self, count: usize) -> Self {
        self.colors_per_row = count;
        self
    }

    /// Show color names
    pub fn show_names(mut self, show: bool) -> Self {
        self.show_names = show;
        self
    }

    /// Show hex values
    pub fn show_hex(mut self, show: bool) -> Self {
        self.show_hex = show;
        self
    }

    /// Compact style
    pub fn compact() -> Self {
        Self::new()
            .colors_per_row(16)
            .show_names(false)
            .show_hex(false)
    }

    /// Detailed style
    pub fn detailed() -> Self {
        Self::new()
            .colors_per_row(4)
            .show_names(true)
            .show_hex(true)
    }
}

/// Color picker component
#[derive(Debug)]
pub struct ColorPicker {
    /// Color palette
    palette: ColorPalette,
    /// Current state
    state: ColorPickerState,
    /// Style
    style: ColorPickerStyle,
    /// Title
    title: Option<String>,
    /// Input mode for disabled/read-only behavior.
    mode: InteractionMode,
}

impl ColorPicker {
    /// Create a new color picker
    pub fn new() -> Self {
        Self {
            palette: ColorPalette::basic(),
            state: ColorPickerState::new(),
            style: ColorPickerStyle::default(),
            title: None,
            mode: InteractionMode::Enabled,
        }
    }

    /// Set the palette
    pub fn palette(mut self, palette: ColorPalette) -> Self {
        self.palette = palette;
        self
    }

    /// Set the state
    pub fn state(mut self, state: ColorPickerState) -> Self {
        self.state = state;
        self
    }

    /// Set the style
    pub fn style(mut self, style: ColorPickerStyle) -> Self {
        self.style = style;
        self
    }

    /// Set title
    pub fn title(mut self, title: impl Into<String>) -> Self {
        self.title = Some(title.into());
        self
    }

    /// Enable normal selection and submit behavior.
    pub fn enabled(mut self) -> Self {
        self.mode = InteractionMode::Enabled;
        self
    }

    /// Ignore all input.
    pub fn disabled(mut self) -> Self {
        self.mode = InteractionMode::Disabled;
        self
    }

    /// Allow rendering/focus while blocking selection changes and submit.
    pub fn read_only(mut self) -> Self {
        self.mode = InteractionMode::ReadOnly;
        self
    }

    /// Set selected color by index
    pub fn selected(mut self, index: usize) -> Self {
        self.state.selected = index;
        self
    }

    /// Get the selected color
    pub fn selected_color(&self) -> Option<Color> {
        self.palette.colors.get(self.state.selected).copied()
    }

    /// Convert color to hex string
    fn color_to_hex(color: &Color) -> String {
        match color {
            Color::Rgb(r, g, b) => format!("#{:02X}{:02X}{:02X}", r, g, b),
            _ => "#??????".to_string(),
        }
    }

    /// Render a color swatch
    fn render_swatch(&self, color: &Color, is_selected: bool) -> String {
        let block = "██";
        let indicator = if is_selected {
            &self.style.selection_indicator
        } else {
            "  "
        };

        format!("{}{}{}{}", color.to_ansi_fg(), block, "\x1b[0m", indicator)
    }

    /// Convert to Element
    pub fn into_element(self) -> Element {
        let mut container = Box::new().flex_direction(FlexDirection::Column);

        // Title
        if let Some(title) = &self.title {
            container = container.child(Text::new(title).into_element());
        }

        // Color grid
        let colors = &self.palette.colors;
        let per_row = self.style.colors_per_row;

        for (row_idx, chunk) in colors.chunks(per_row).enumerate() {
            let mut row_str = String::new();

            for (col_idx, color) in chunk.iter().enumerate() {
                let idx = row_idx * per_row + col_idx;
                let is_selected = idx == self.state.selected;
                row_str.push_str(&self.render_swatch(color, is_selected));
            }

            container = container.child(Text::new(row_str).into_element());
        }

        // Selected color info
        if self.style.show_hex || self.style.show_names {
            if let Some(color) = self.selected_color() {
                let mut info = String::new();

                if self.style.show_hex {
                    info.push_str(&Self::color_to_hex(&color));
                }

                if !info.is_empty() {
                    container = container.child(Text::new(info).into_element());
                }
            }
        }

        let mut accessibility = AccessibilityProps::new(AccessibilityRole::ColorPicker)
            .label(
                self.title
                    .clone()
                    .unwrap_or_else(|| "Color picker".to_string()),
            )
            .description(format!("{} colors", self.palette.colors.len()))
            .disabled(self.mode.is_disabled())
            .read_only(self.mode.is_read_only())
            .focusable(!self.mode.is_disabled());
        if let Some(color) = self.selected_color() {
            accessibility = accessibility.value(Self::color_to_hex(&color));
        }

        container.into_element().with_accessibility(accessibility)
    }
}

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

/// Handle ColorPicker navigation, submit, and cancel against explicit state.
pub fn handle_color_picker_input(
    state: &mut ColorPickerState,
    palette: &[Color],
    colors_per_row: usize,
    key: &crate::hooks::Key,
    mode: InteractionMode,
) -> InteractionOutcome<Color> {
    if mode.is_disabled() || palette.is_empty() {
        return InteractionOutcome::Ignored;
    }

    if key.escape {
        state.close();
        return InteractionOutcome::Cancelled;
    }

    if mode.is_read_only() {
        return InteractionOutcome::Ignored;
    }

    let max = palette.len();
    let row = colors_per_row.max(1);
    let mut next = state.selected.min(max - 1);

    if key.left_arrow {
        next = next.saturating_sub(1);
    } else if key.right_arrow {
        next = (next + 1).min(max - 1);
    } else if key.up_arrow {
        next = next.saturating_sub(row);
    } else if key.down_arrow {
        next = (next + row).min(max - 1);
    } else if key.home {
        next = 0;
    } else if key.end {
        next = max - 1;
    } else if key.return_key || key.space {
        return InteractionOutcome::Submitted(palette[next]);
    } else {
        return InteractionOutcome::Ignored;
    }

    state.select(next);
    InteractionOutcome::Changed(palette[next])
}

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

    #[test]
    fn test_color_palette_basic() {
        let palette = ColorPalette::basic();
        assert_eq!(palette.colors.len(), 16);
    }

    #[test]
    fn test_color_palette_grayscale() {
        let palette = ColorPalette::grayscale();
        assert_eq!(palette.colors.len(), 24);
    }

    #[test]
    fn test_color_palette_presets() {
        let _ = ColorPalette::rainbow();
        let _ = ColorPalette::pastel();
        let _ = ColorPalette::material();
    }

    #[test]
    fn test_color_picker_state() {
        let mut state = ColorPickerState::new();
        assert!(!state.open);

        state.open();
        assert!(state.open);

        state.close();
        assert!(!state.open);
    }

    #[test]
    fn test_color_picker_state_navigation() {
        let mut state = ColorPickerState::new();
        state.selected = 0;

        state.select_next(5);
        assert_eq!(state.selected, 1);

        state.select_prev(5);
        assert_eq!(state.selected, 0);

        // Wrap around
        state.select_prev(5);
        assert_eq!(state.selected, 4);
    }

    #[test]
    fn test_color_picker_creation() {
        let picker = ColorPicker::new();
        assert_eq!(picker.palette.colors.len(), 16);
    }

    #[test]
    fn test_color_picker_selected_color() {
        let picker = ColorPicker::new().selected(0);
        let color = picker.selected_color();
        assert!(color.is_some());
    }

    #[test]
    fn test_color_picker_style() {
        let style = ColorPickerStyle::new().colors_per_row(4).show_hex(true);

        assert_eq!(style.colors_per_row, 4);
        assert!(style.show_hex);
    }

    #[test]
    fn test_color_picker_into_element() {
        let picker = ColorPicker::new();
        let _ = picker.into_element();
    }

    #[test]
    fn test_color_to_hex() {
        let hex = ColorPicker::color_to_hex(&Color::Rgb(255, 0, 128));
        assert_eq!(hex, "#FF0080");
    }

    #[test]
    fn test_handle_color_picker_input_modes_and_submit() {
        let palette = ColorPalette::basic();
        let mut state = ColorPickerState::new();

        let outcome = handle_color_picker_input(
            &mut state,
            &palette.colors,
            8,
            &crate::hooks::Key {
                right_arrow: true,
                ..Default::default()
            },
            InteractionMode::Enabled,
        );
        assert_eq!(outcome, InteractionOutcome::Changed(Color::Red));
        assert_eq!(state.selected, 1);

        let outcome = handle_color_picker_input(
            &mut state,
            &palette.colors,
            8,
            &crate::hooks::Key {
                right_arrow: true,
                ..Default::default()
            },
            InteractionMode::ReadOnly,
        );
        assert_eq!(outcome, InteractionOutcome::Ignored);
        assert_eq!(state.selected, 1);

        let outcome = handle_color_picker_input(
            &mut state,
            &palette.colors,
            8,
            &crate::hooks::Key {
                return_key: true,
                ..Default::default()
            },
            InteractionMode::Enabled,
        );
        assert_eq!(outcome, InteractionOutcome::Submitted(Color::Red));
    }
}