term39 0.6.0

use crate::charset::Charset;
use crate::theme::Theme;
use crate::video_buffer::{self, Cell, VideoBuffer};
use crossterm::style::Color;

/// Prompt types with different visual styles (similar to Bootstrap alerts)
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PromptType {
    #[allow(dead_code)]
    Info, // Blue theme
    #[allow(dead_code)]
    Success, // Green theme
    #[allow(dead_code)]
    Warning, // Yellow theme
    Danger, // Red theme
}

impl PromptType {
    /// Get the background color for this prompt type
    pub fn background_color(&self, theme: &Theme) -> Color {
        match self {
            PromptType::Info => theme.prompt_info_bg,
            PromptType::Success => theme.prompt_success_bg,
            PromptType::Warning => theme.prompt_warning_bg,
            PromptType::Danger => theme.prompt_danger_bg,
        }
    }

    /// Get the foreground color for this prompt type
    pub fn foreground_color(&self, theme: &Theme) -> Color {
        match self {
            PromptType::Info => theme.prompt_info_fg,
            PromptType::Success => theme.prompt_success_fg,
            PromptType::Warning => theme.prompt_warning_fg,
            PromptType::Danger => theme.prompt_danger_fg,
        }
    }
}

/// Button in a prompt
#[derive(Clone, Debug)]
pub struct PromptButton {
    pub text: String,
    pub action: PromptAction,
    pub is_primary: bool, // Primary buttons have attractive colors, secondary are muted
}

/// Action to take when a button is clicked
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PromptAction {
    Confirm,
    Cancel,
    #[allow(dead_code)]
    Custom(u32),
}

impl PromptButton {
    /// Create a new button
    pub fn new(text: String, action: PromptAction, is_primary: bool) -> Self {
        Self {
            text,
            action,
            is_primary,
        }
    }

    /// Get button colors based on whether it's primary
    pub fn colors(&self, prompt_type: PromptType, theme: &Theme) -> (Color, Color) {
        if self.is_primary {
            // Primary button: attractive colors based on prompt type
            match prompt_type {
                PromptType::Info => (
                    theme.dialog_button_primary_info_fg,
                    theme.dialog_button_primary_info_bg,
                ),
                PromptType::Success => (
                    theme.dialog_button_primary_success_fg,
                    theme.dialog_button_primary_success_bg,
                ),
                PromptType::Warning => (
                    theme.dialog_button_primary_warning_fg,
                    theme.dialog_button_primary_warning_bg,
                ),
                PromptType::Danger => (
                    theme.dialog_button_primary_danger_fg,
                    theme.dialog_button_primary_danger_bg,
                ),
            }
        } else {
            // Secondary button: muted colors
            (
                theme.dialog_button_secondary_fg,
                theme.dialog_button_secondary_bg,
            )
        }
    }

    /// Get the rendered width of the button (includes brackets and spaces)
    pub fn width(&self) -> u16 {
        // Format: [ Text ]
        self.text.len() as u16 + 4
    }
}

/// Text alignment for prompt messages
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TextAlign {
    #[allow(dead_code)]
    Left,
    Center,
}

/// A modal prompt dialog (no title bar, centered on screen)
pub struct Prompt {
    pub prompt_type: PromptType,
    pub message: String,
    pub buttons: Vec<PromptButton>,
    pub width: u16,
    pub height: u16,
    pub x: u16,
    pub y: u16,
    pub selected_button_index: usize, // Index of currently selected button for keyboard navigation
    pub text_align: TextAlign,        // Text alignment for the message
}

impl Prompt {
    /// Create a new prompt (auto-sized and centered) with center alignment
    pub fn new(
        prompt_type: PromptType,
        message: String,
        buttons: Vec<PromptButton>,
        buffer_width: u16,
        buffer_height: u16,
    ) -> Self {
        Self::new_with_alignment(
            prompt_type,
            message,
            buttons,
            buffer_width,
            buffer_height,
            TextAlign::Center,
        )
    }

    /// Create a new prompt (auto-sized and centered) with custom alignment
    pub fn new_with_alignment(
        prompt_type: PromptType,
        message: String,
        buttons: Vec<PromptButton>,
        buffer_width: u16,
        buffer_height: u16,
        text_align: TextAlign,
    ) -> Self {
        // Calculate dimensions
        let message_lines: Vec<&str> = message.lines().collect();

        // Strip color codes when calculating width
        let max_message_width = message_lines
            .iter()
            .map(|line| Self::strip_color_codes(line).len())
            .max()
            .unwrap_or(0) as u16;

        // Calculate total button width (with spacing)
        let total_button_width: u16 = buttons.iter().map(|b| b.width()).sum::<u16>()
            + (buttons.len().saturating_sub(1)) as u16 * 2; // 2 spaces between buttons

        // Width is max of message width and button width, plus padding
        let content_width = max_message_width.max(total_button_width);
        let width = content_width + 6; // 2 for padding on each side + 2 for borders

        // Height: message lines + padding + button row
        let height = message_lines.len() as u16 + 6; // 1 top padding + message + 1 padding + buttons + 1 padding + borders

        // Center on screen
        let x = (buffer_width.saturating_sub(width)) / 2;
        let y = (buffer_height.saturating_sub(height)) / 2;

        // Find the first primary button as default selection, or use first button
        let selected_button_index = buttons.iter().position(|b| b.is_primary).unwrap_or(0);

        Self {
            prompt_type,
            message,
            buttons,
            width,
            height,
            x,
            y,
            selected_button_index,
            text_align,
        }
    }

    /// Strip color codes from a string for length calculation
    fn strip_color_codes(s: &str) -> String {
        let mut result = String::new();
        let mut chars = s.chars();
        while let Some(ch) = chars.next() {
            if ch == '{' {
                // Skip until we find '}'
                for next in chars.by_ref() {
                    if next == '}' {
                        break;
                    }
                }
            } else {
                result.push(ch);
            }
        }
        result
    }

    /// Parse color code and return the corresponding Color
    fn parse_color_code(code: &str) -> Option<Color> {
        match code {
            "Y" | "y" => Some(Color::Yellow),
            "C" | "c" => Some(Color::Cyan),
            "W" | "w" => Some(Color::White),
            "G" | "g" => Some(Color::Green),
            "R" | "r" => Some(Color::Red),
            "M" | "m" => Some(Color::Magenta),
            "B" | "b" => Some(Color::Blue),
            "DG" | "dg" => Some(Color::DarkGrey),
            _ => None,
        }
    }

    /// Render the prompt to the video buffer
    pub fn render(&self, buffer: &mut VideoBuffer, charset: &Charset, theme: &Theme) {
        let bg_color = self.prompt_type.background_color(theme);
        let default_fg_color = self.prompt_type.foreground_color(theme);

        // Fill the entire prompt area with the background color (no borders)
        for y in 0..self.height {
            for x in 0..self.width {
                buffer.set(
                    self.x + x,
                    self.y + y,
                    Cell::new(' ', default_fg_color, bg_color),
                );
            }
        }

        // Render message (with alignment and color support)
        let message_lines: Vec<&str> = self.message.lines().collect();
        let message_start_y = self.y + 2; // Leave space at top

        for (i, line) in message_lines.iter().enumerate() {
            let line_y = message_start_y + i as u16;

            // Calculate line_x based on alignment
            let stripped_line = Self::strip_color_codes(line);
            let line_x = match self.text_align {
                TextAlign::Center => {
                    self.x + (self.width.saturating_sub(stripped_line.len() as u16)) / 2
                }
                TextAlign::Left => self.x + 3, // 3 spaces from left edge
            };

            // Render line with color code parsing
            let mut current_x = line_x;
            let mut current_color = default_fg_color;
            let mut chars = line.chars();

            while let Some(ch) = chars.next() {
                if ch == '{' {
                    // Collect color code
                    let mut code = String::new();
                    for next in chars.by_ref() {
                        if next == '}' {
                            // Apply color if valid
                            if let Some(color) = Self::parse_color_code(&code) {
                                current_color = color;
                            }
                            break;
                        }
                        code.push(next);
                    }
                } else {
                    // Render character with current color
                    buffer.set(current_x, line_y, Cell::new(ch, current_color, bg_color));
                    current_x += 1;
                }
            }
        }

        // Render buttons (centered, at bottom)
        let button_y = self.y + self.height - 2;
        let total_button_width: u16 = self.buttons.iter().map(|b| b.width()).sum::<u16>()
            + (self.buttons.len().saturating_sub(1)) as u16 * 2; // 2 spaces between buttons

        let mut button_x = self.x + (self.width.saturating_sub(total_button_width)) / 2;

        for (index, button) in self.buttons.iter().enumerate() {
            let (button_fg, button_bg) = button.colors(self.prompt_type, theme);
            let is_selected = index == self.selected_button_index;

            // Render selection indicator before button
            if is_selected {
                // Add ">" indicator before selected button (1 cell to the left)
                if button_x > self.x {
                    buffer.set(
                        button_x - 1,
                        button_y,
                        Cell::new('>', default_fg_color, bg_color),
                    );
                }
            }

            // Render button: [ Text ]
            buffer.set(button_x, button_y, Cell::new('[', button_fg, button_bg));
            button_x += 1;
            buffer.set(button_x, button_y, Cell::new(' ', button_fg, button_bg));
            button_x += 1;

            for ch in button.text.chars() {
                buffer.set(button_x, button_y, Cell::new(ch, button_fg, button_bg));
                button_x += 1;
            }

            buffer.set(button_x, button_y, Cell::new(' ', button_fg, button_bg));
            button_x += 1;
            buffer.set(button_x, button_y, Cell::new(']', button_fg, button_bg));
            button_x += 1;

            // Render selection indicator after button
            if is_selected {
                buffer.set(
                    button_x,
                    button_y,
                    Cell::new('<', default_fg_color, bg_color),
                );
            }

            // Add spacing between buttons
            button_x += 2;
        }

        // Render shadow
        video_buffer::render_shadow(
            buffer,
            self.x,
            self.y,
            self.width,
            self.height,
            charset,
            theme,
        );
    }

    /// Check if a click is on a button, return the action if so
    pub fn handle_click(&self, x: u16, y: u16) -> Option<PromptAction> {
        let button_y = self.y + self.height - 2;

        // Only process clicks on the button row
        if y != button_y {
            return None;
        }

        let total_button_width: u16 = self.buttons.iter().map(|b| b.width()).sum::<u16>()
            + (self.buttons.len().saturating_sub(1)) as u16 * 2;

        let mut button_x = self.x + (self.width.saturating_sub(total_button_width)) / 2;

        for button in &self.buttons {
            let button_width = button.width();
            let button_end = button_x + button_width;

            if x >= button_x && x < button_end {
                return Some(button.action);
            }

            button_x = button_end + 2; // Move to next button (with spacing)
        }

        None
    }

    /// Check if point is within prompt bounds
    pub fn contains_point(&self, x: u16, y: u16) -> bool {
        x >= self.x && x < self.x + self.width && y >= self.y && y < self.y + self.height
    }

    /// Move selection to the next button (right/tab)
    pub fn select_next_button(&mut self) {
        if !self.buttons.is_empty() {
            self.selected_button_index = (self.selected_button_index + 1) % self.buttons.len();
        }
    }

    /// Move selection to the previous button (left/shift+tab)
    pub fn select_previous_button(&mut self) {
        if !self.buttons.is_empty() {
            self.selected_button_index = if self.selected_button_index == 0 {
                self.buttons.len() - 1
            } else {
                self.selected_button_index - 1
            };
        }
    }

    /// Get the action of the currently selected button
    pub fn get_selected_action(&self) -> Option<PromptAction> {
        self.buttons
            .get(self.selected_button_index)
            .map(|b| b.action)
    }
}

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

    #[test]
    fn test_prompt_creation() {
        let buttons = vec![
            PromptButton::new("Yes".to_string(), PromptAction::Confirm, true),
            PromptButton::new("No".to_string(), PromptAction::Cancel, false),
        ];

        let prompt = Prompt::new(
            PromptType::Danger,
            "Are you sure?".to_string(),
            buttons,
            80,
            24,
        );

        assert_eq!(prompt.prompt_type, PromptType::Danger);
        assert_eq!(prompt.buttons.len(), 2);
    }

    #[test]
    fn test_button_width() {
        let button = PromptButton::new("OK".to_string(), PromptAction::Confirm, true);
        assert_eq!(button.width(), 6); // "[ OK ]"
    }
}