xacli_components/components/

progress.rs

use std::{
    io::{stdout, Write},
    sync::mpsc::{self, Receiver, RecvTimeoutError, Sender},
    time::Duration,
};

use crossterm::{
    cursor, queue,
    style::Print,
    terminal::{self, ClearType},
};

use crate::Result;

pub struct ProgressBar {
    total: u64,
    message: String,
    rx: Receiver<ProgressEvent>,
}

pub struct ProgressHandle {
    tx: Sender<ProgressEvent>,
}

pub enum ProgressEvent {
    Increment(u64),
    SetProgress(u64),
    SetMessage(String),
    Finish,
}

impl ProgressBar {
    pub fn new(total: u64, message: impl Into<String>) -> (Self, ProgressHandle) {
        let (tx, rx) = mpsc::channel();
        let bar = Self {
            total,
            message: message.into(),
            rx,
        };
        let handle = ProgressHandle { tx };
        (bar, handle)
    }

    pub fn run(mut self) -> Result<()> {
        let mut stdout = stdout();
        let mut current = 0u64;

        self.render(&mut stdout, current)?;

        loop {
            match self.rx.recv_timeout(Duration::from_millis(100)) {
                Ok(ProgressEvent::Increment(n)) => {
                    current = (current + n).min(self.total);
                    self.render(&mut stdout, current)?;
                }
                Ok(ProgressEvent::SetProgress(n)) => {
                    current = n.min(self.total);
                    self.render(&mut stdout, current)?;
                }
                Ok(ProgressEvent::SetMessage(msg)) => {
                    self.message = msg;
                    self.render(&mut stdout, current)?;
                }
                Ok(ProgressEvent::Finish) => {
                    current = self.total;
                    self.render(&mut stdout, current)?;
                    println!(); // 换行
                    break;
                }
                Err(RecvTimeoutError::Timeout) => {
                    // 定期刷新
                    self.render(&mut stdout, current)?;
                }
                Err(RecvTimeoutError::Disconnected) => {
                    println!(); // 换行
                    break;
                }
            }
        }

        Ok(())
    }

    fn render(&self, stdout: &mut impl Write, current: u64) -> Result<()> {
        let percent = if self.total > 0 {
            (current as f64 / self.total as f64) * 100.0
        } else {
            0.0
        };

        let bar_width = 40;
        let filled = if self.total > 0 {
            ((current as f64 / self.total as f64) * bar_width as f64) as usize
        } else {
            0
        };
        let bar = format!("[{}{}]", "=".repeat(filled), " ".repeat(bar_width - filled));

        queue!(
            stdout,
            cursor::MoveToColumn(0),
            terminal::Clear(ClearType::CurrentLine),
            Print(&self.message),
            Print(" "),
            Print(&bar),
            Print(format!(" {}/{} ({:.1}%)", current, self.total, percent)),
        )?;

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

impl ProgressHandle {
    pub fn inc(&self, n: u64) {
        let _ = self.tx.send(ProgressEvent::Increment(n));
    }

    pub fn set(&self, n: u64) {
        let _ = self.tx.send(ProgressEvent::SetProgress(n));
    }

    pub fn set_message(&self, msg: impl Into<String>) {
        let _ = self.tx.send(ProgressEvent::SetMessage(msg.into()));
    }

    pub fn finish(&self) {
        let _ = self.tx.send(ProgressEvent::Finish);
    }
}

#[cfg(test)]
mod tests {
    use std::{thread, time::Duration};

    use super::*;

    #[test]
    fn test_progress_bar_new() {
        let (bar, _handle) = ProgressBar::new(100, "Downloading");
        assert_eq!(bar.total, 100);
        assert_eq!(bar.message, "Downloading");
    }

    #[test]
    fn test_progress_handle_inc() {
        let (bar, handle) = ProgressBar::new(100, "Test");

        handle.inc(10);
        handle.inc(20);

        // Check that events are received
        let event1 = bar.rx.recv_timeout(Duration::from_millis(100)).unwrap();
        assert!(matches!(event1, ProgressEvent::Increment(10)));

        let event2 = bar.rx.recv_timeout(Duration::from_millis(100)).unwrap();
        assert!(matches!(event2, ProgressEvent::Increment(20)));
    }

    #[test]
    fn test_progress_handle_set() {
        let (bar, handle) = ProgressBar::new(100, "Test");

        handle.set(50);

        let event = bar.rx.recv_timeout(Duration::from_millis(100)).unwrap();
        assert!(matches!(event, ProgressEvent::SetProgress(50)));
    }

    #[test]
    fn test_progress_handle_set_message() {
        let (bar, handle) = ProgressBar::new(100, "Test");

        handle.set_message("New message");

        let event = bar.rx.recv_timeout(Duration::from_millis(100)).unwrap();
        match event {
            ProgressEvent::SetMessage(msg) => assert_eq!(msg, "New message"),
            _ => panic!("Expected SetMessage event"),
        }
    }

    #[test]
    fn test_progress_handle_finish() {
        let (bar, handle) = ProgressBar::new(100, "Test");

        handle.finish();

        let event = bar.rx.recv_timeout(Duration::from_millis(100)).unwrap();
        assert!(matches!(event, ProgressEvent::Finish));
    }

    #[test]
    fn test_render_zero_total() {
        let (bar, _handle) = ProgressBar::new(0, "Test");
        let mut output = Vec::new();

        // render should handle zero total without division by zero
        bar.render(&mut output, 0).unwrap();

        // Output contains ANSI escape sequences, just verify it doesn't panic
        assert!(!output.is_empty());
    }

    #[test]
    fn test_render_with_progress() {
        let (bar, _handle) = ProgressBar::new(100, "Loading");
        let mut output = Vec::new();

        bar.render(&mut output, 50).unwrap();

        let output_str = String::from_utf8_lossy(&output);
        assert!(output_str.contains("Loading"));
        assert!(output_str.contains("50/100"));
        assert!(output_str.contains("50.0%"));
    }

    #[test]
    fn test_render_full_progress() {
        let (bar, _handle) = ProgressBar::new(100, "Done");
        let mut output = Vec::new();

        bar.render(&mut output, 100).unwrap();

        let output_str = String::from_utf8_lossy(&output);
        assert!(output_str.contains("100/100"));
        assert!(output_str.contains("100.0%"));
    }

    #[test]
    fn test_progress_bar_run_with_finish() {
        let (bar, handle) = ProgressBar::new(10, "Test");

        // Spawn a thread to finish the progress bar
        let finish_thread = thread::spawn(move || {
            thread::sleep(Duration::from_millis(50));
            handle.inc(5);
            thread::sleep(Duration::from_millis(50));
            handle.finish();
        });

        // Run should complete when finish is called
        let result = bar.run();
        assert!(result.is_ok());

        finish_thread.join().unwrap();
    }

    #[test]
    fn test_progress_bar_run_with_disconnect() {
        let (bar, handle) = ProgressBar::new(10, "Test");

        // Spawn a thread to drop the handle (disconnect)
        let drop_thread = thread::spawn(move || {
            thread::sleep(Duration::from_millis(50));
            drop(handle);
        });

        // Run should complete when handle is dropped
        let result = bar.run();
        assert!(result.is_ok());

        drop_thread.join().unwrap();
    }

    #[test]
    fn test_progress_handle_after_disconnect() {
        let (bar, handle) = ProgressBar::new(100, "Test");

        // Drop the bar (receiver)
        drop(bar);

        // Sending should not panic, just silently fail
        handle.inc(10);
        handle.set(50);
        handle.set_message("test");
        handle.finish();
    }

    #[test]
    fn test_progress_clamp_to_max() {
        let (bar, handle) = ProgressBar::new(100, "Test");

        // Set progress beyond total
        handle.set(200);

        let event = bar.rx.recv_timeout(Duration::from_millis(100)).unwrap();
        // Event should still have the value 200, clamping happens in run()
        assert!(matches!(event, ProgressEvent::SetProgress(200)));
    }
}