xacli_components/components/

select.rs

use std::io::{stdout, Write};

use crossterm::{
    cursor,
    event::{Event, KeyCode, KeyModifiers},
    queue,
    style::Print,
    terminal::{self, ClearType},
};

use super::read_event;
use crate::{ComponentError, Result};

pub struct Select<T> {
    prompt: String,
    options: Vec<(String, T)>,
}

impl<T> Select<T> {
    pub fn new(prompt: impl Into<String>) -> Self {
        Self {
            prompt: prompt.into(),
            options: Vec::new(),
        }
    }

    pub fn option(mut self, label: impl Into<String>, value: T) -> Self {
        self.options.push((label.into(), value));
        self
    }

    pub fn options(mut self, options: Vec<(String, T)>) -> Self {
        self.options = options;
        self
    }

    pub fn run(self) -> Result<T> {
        if self.options.is_empty() {
            return Err(ComponentError::InvalidInput("No options provided".into()));
        }

        let mut stdout = stdout();
        terminal::enable_raw_mode()?;

        let result = self.run_inner(&mut stdout);

        terminal::disable_raw_mode()?;

        result
    }

    /// Run with custom output writer (for testing)
    #[cfg(test)]
    pub fn run_with_output(self, output: &mut impl Write) -> Result<T> {
        if self.options.is_empty() {
            return Err(ComponentError::InvalidInput("No options provided".into()));
        }
        self.run_inner(output)
    }

    fn run_inner(mut self, stdout: &mut impl Write) -> Result<T> {
        let mut selected = 0;
        let mut first_render = true;

        self.render(stdout, selected, first_render)?;
        first_render = false;

        loop {
            if let Event::Key(key) = read_event()? {
                match key.code {
                    KeyCode::Enter => {
                        // 清除渲染
                        self.clear_render(stdout)?;
                        // Use \r\n to properly handle raw mode
                        queue!(
                            stdout,
                            cursor::MoveToColumn(0),
                            Print("✓ "),
                            Print(&self.options[selected].0),
                            Print("\r\n")
                        )?;
                        stdout.flush()?;
                        return Ok(self.options.remove(selected).1);
                    }
                    KeyCode::Esc => {
                        self.clear_render(stdout)?;
                        return Err(ComponentError::Interrupted);
                    }
                    KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        self.clear_render(stdout)?;
                        return Err(ComponentError::Interrupted);
                    }
                    KeyCode::Up | KeyCode::Char('k') => {
                        if selected > 0 {
                            selected -= 1;
                            self.render(stdout, selected, first_render)?;
                        }
                    }
                    KeyCode::Down | KeyCode::Char('j') => {
                        if selected < self.options.len() - 1 {
                            selected += 1;
                            self.render(stdout, selected, first_render)?;
                        }
                    }
                    KeyCode::Home => {
                        selected = 0;
                        self.render(stdout, selected, first_render)?;
                    }
                    KeyCode::End => {
                        selected = self.options.len() - 1;
                        self.render(stdout, selected, first_render)?;
                    }
                    _ => {}
                }
            }
        }
    }

    fn render(&self, stdout: &mut impl Write, selected: usize, first_render: bool) -> Result<()> {
        if !first_render {
            // 清除之前的渲染
            for _ in 0..self.options.len() + 1 {
                queue!(
                    stdout,
                    cursor::MoveUp(1),
                    terminal::Clear(ClearType::CurrentLine),
                )?;
            }
        }

        queue!(stdout, cursor::MoveToColumn(0))?;

        // 提示
        queue!(stdout, Print(&self.prompt), Print("\r\n"))?;

        // 选项
        for (i, (label, _)) in self.options.iter().enumerate() {
            let marker = if i == selected { ">" } else { " " };
            queue!(
                stdout,
                cursor::MoveToColumn(0),
                Print(marker),
                Print(" "),
                Print(label),
                Print("\r\n"),
            )?;
        }

        stdout.flush()?;
        Ok(())
    }

    fn clear_render(&self, stdout: &mut impl Write) -> Result<()> {
        for _ in 0..self.options.len() + 1 {
            queue!(
                stdout,
                cursor::MoveUp(1),
                terminal::Clear(ClearType::CurrentLine),
            )?;
        }
        queue!(stdout, cursor::MoveToColumn(0))?;
        stdout.flush()?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use std::sync::mpsc;

    use xacli_testing::{EventBuilder, OutputCapture};

    use super::*;
    use crate::components::{clear_test_event_source, set_test_event_source};

    fn setup_events(events: Vec<Event>) -> mpsc::Sender<Event> {
        let (tx, rx) = mpsc::channel();
        set_test_event_source(rx);
        for event in events {
            tx.send(event).unwrap();
        }
        tx
    }

    #[test]
    fn test_select_first_option() {
        let _tx = setup_events(vec![EventBuilder::enter()]);

        let mut output = OutputCapture::new();
        let result = Select::new("Choose:")
            .option("Option A", 1)
            .option("Option B", 2)
            .option("Option C", 3)
            .run_with_output(&mut output)
            .unwrap();

        assert_eq!(result, 1);
        clear_test_event_source();
    }

    #[test]
    fn test_select_navigate_down() {
        let _tx = setup_events(vec![
            EventBuilder::down(),
            EventBuilder::down(),
            EventBuilder::enter(),
        ]);

        let mut output = OutputCapture::new();
        let result = Select::new("Choose:")
            .option("Option A", 1)
            .option("Option B", 2)
            .option("Option C", 3)
            .run_with_output(&mut output)
            .unwrap();

        assert_eq!(result, 3);
        clear_test_event_source();
    }

    #[test]
    fn test_select_navigate_with_j_k() {
        let _tx = setup_events(vec![
            EventBuilder::char('j'), // Down
            EventBuilder::char('j'), // Down
            EventBuilder::char('k'), // Up
            EventBuilder::enter(),
        ]);

        let mut output = OutputCapture::new();
        let result = Select::new("Choose:")
            .option("Option A", 1)
            .option("Option B", 2)
            .option("Option C", 3)
            .run_with_output(&mut output)
            .unwrap();

        assert_eq!(result, 2);
        clear_test_event_source();
    }

    #[test]
    fn test_select_home_end() {
        let _tx = setup_events(vec![
            EventBuilder::end(),  // Go to last
            EventBuilder::home(), // Go to first
            EventBuilder::enter(),
        ]);

        let mut output = OutputCapture::new();
        let result = Select::new("Choose:")
            .option("Option A", 1)
            .option("Option B", 2)
            .option("Option C", 3)
            .run_with_output(&mut output)
            .unwrap();

        assert_eq!(result, 1);
        clear_test_event_source();
    }

    #[test]
    fn test_select_escape_interrupts() {
        let _tx = setup_events(vec![EventBuilder::escape()]);

        let mut output = OutputCapture::new();
        let result = Select::<i32>::new("Choose:")
            .option("Option A", 1)
            .option("Option B", 2)
            .run_with_output(&mut output);

        assert!(matches!(result, Err(ComponentError::Interrupted)));
        clear_test_event_source();
    }

    #[test]
    fn test_select_no_options() {
        let mut output = OutputCapture::new();
        let result = Select::<i32>::new("Choose:").run_with_output(&mut output);

        assert!(matches!(result, Err(ComponentError::InvalidInput(_))));
    }
}