use indicatif::{MultiProgress, ProgressBar, ProgressDrawTarget, ProgressStyle};
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::Mutex;
#[derive(Clone)]
pub struct ProgressManager {
multi_progress: Arc<MultiProgress>,
main_progress: Arc<Mutex<Option<ProgressBar>>>,
chunk_progresses: Arc<Mutex<Vec<ProgressBar>>>,
start_time: Arc<Mutex<Option<Instant>>>,
downloaded_bytes: Arc<Mutex<u64>>,
last_update: Arc<Mutex<Instant>>,
last_downloaded: Arc<Mutex<u64>>, }
impl ProgressManager {
pub fn new() -> Self {
let multi_progress = MultiProgress::new();
multi_progress.set_draw_target(ProgressDrawTarget::stdout_with_hz(10));
Self {
multi_progress: Arc::new(multi_progress),
main_progress: Arc::new(Mutex::new(None)),
chunk_progresses: Arc::new(Mutex::new(Vec::new())),
start_time: Arc::new(Mutex::new(None)),
downloaded_bytes: Arc::new(Mutex::new(0)),
last_update: Arc::new(Mutex::new(Instant::now())),
last_downloaded: Arc::new(Mutex::new(0)),
}
}
pub async fn init_main_progress(&self, total_size: u64, initial_downloaded: u64) {
let pb = self.multi_progress.add(ProgressBar::new(total_size));
pb.set_position(initial_downloaded);
pb.set_style(
ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {bytes:>9}/{total_bytes:>9} ({percent:>3}%) {msg}")
.unwrap()
.progress_chars("█▉▊▋▌▍▎▏ ")
);
pb.set_message("Initializing...".to_string());
*self.main_progress.lock().await = Some(pb);
*self.start_time.lock().await = Some(Instant::now());
*self.downloaded_bytes.lock().await = initial_downloaded;
*self.last_downloaded.lock().await = initial_downloaded;
}
pub async fn add_chunk_progress(&self, thread_id: usize, total_size: u64) -> ProgressBar {
let pb = self.multi_progress.add(ProgressBar::new(total_size));
pb.set_style(
ProgressStyle::with_template(&format!(
"Thread {:2}: [{{bar:30.cyan}}] {{bytes:>7}}/{{total_bytes:>7}} ({{percent:>2}}%)",
thread_id
))
.unwrap()
.progress_chars("█▉▊▋▌▍▎▏ "),
);
let mut chunk_progresses = self.chunk_progresses.lock().await;
if chunk_progresses.len() <= thread_id {
chunk_progresses.resize(thread_id + 1, ProgressBar::hidden());
}
chunk_progresses[thread_id] = pb.clone();
pb
}
fn format_speed(speed_bytes_per_sec: f64) -> String {
const KB: f64 = 1024.0;
const MB: f64 = 1024.0 * 1024.0;
const GB: f64 = 1024.0 * 1024.0 * 1024.0;
if speed_bytes_per_sec >= GB {
format!("{:.1} GiB/s", speed_bytes_per_sec / GB)
} else if speed_bytes_per_sec >= MB {
format!("{:.1} MiB/s", speed_bytes_per_sec / MB)
} else if speed_bytes_per_sec >= KB {
format!("{:.1} KiB/s", speed_bytes_per_sec / KB)
} else {
format!("{:.0} B/s", speed_bytes_per_sec)
}
}
pub async fn update_main_progress(&self, increment: u64) {
if let Some(pb) = &*self.main_progress.lock().await {
pb.inc(increment);
let mut downloaded = self.downloaded_bytes.lock().await;
*downloaded += increment;
let now = Instant::now();
let last_update = *self.last_update.lock().await;
let mut last_downloaded = self.last_downloaded.lock().await;
let time_diff = now.duration_since(last_update).as_secs_f64();
if time_diff >= 2.0 {
let downloaded_diff = *downloaded - *last_downloaded;
let speed_bytes_per_sec = (downloaded_diff as f64) / time_diff;
let speed_str = if speed_bytes_per_sec > 0.0 {
Self::format_speed(speed_bytes_per_sec)
} else {
"0 B/s".to_string()
};
let msg = format!(
"Speed: {} | Active threads: {}",
speed_str,
self.get_active_threads_count().await
);
pb.set_message(msg);
*last_downloaded = *downloaded;
*self.last_update.lock().await = now;
} else if time_diff >= 0.5 {
let downloaded_diff = *downloaded - *last_downloaded;
if downloaded_diff > 0 {
let speed_bytes_per_sec = (downloaded_diff as f64) / time_diff;
let speed_str = Self::format_speed(speed_bytes_per_sec);
let msg = format!(
"Speed: {} | Active threads: {}",
speed_str,
self.get_active_threads_count().await
);
pb.set_message(msg);
}
}
}
}
pub async fn finish_main_progress(&self, message: &str) {
if let Some(pb) = &*self.main_progress.lock().await {
if let Some(start_time) = *self.start_time.lock().await {
let elapsed = start_time.elapsed().as_secs_f64();
let total_downloaded = *self.downloaded_bytes.lock().await;
if elapsed > 0.0 {
let avg_speed = total_downloaded as f64 / elapsed;
let avg_speed_str = Self::format_speed(avg_speed);
println!("📊 Average speed: {}", avg_speed_str);
}
}
pb.finish_with_message(message.to_string());
let mut chunk_progresses = self.chunk_progresses.lock().await;
for chunk_pb in chunk_progresses.iter_mut() {
chunk_pb.finish_and_clear();
}
}
}
pub async fn set_main_message(&self, message: &str) {
if let Some(pb) = &*self.main_progress.lock().await {
pb.set_message(message.to_string());
}
}
pub async fn get_active_threads_count(&self) -> usize {
let chunk_progresses = self.chunk_progresses.lock().await;
chunk_progresses
.iter()
.filter(|pb| !pb.is_finished())
.count()
}
pub async fn check_stalled(&self) -> bool {
let last_update = *self.last_update.lock().await;
last_update.elapsed() > Duration::from_secs(120) }
pub async fn get_total_downloaded(&self) -> u64 {
*self.downloaded_bytes.lock().await
}
pub fn create_simple_progress(&self, total_size: u64) -> ProgressBar {
let pb = self.multi_progress.add(ProgressBar::new(total_size));
pb.set_style(
ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] [{bar:40}] {bytes:>9}/{total_bytes:>9} ({percent:>3}%) {msg}")
.unwrap()
.progress_chars("█▉▊▋▌▍▎▏ ")
);
pb
}
pub async fn update_simple_progress_speed(&self, pb: &ProgressBar, downloaded: u64) {
if let Some(start_time) = *self.start_time.lock().await {
let elapsed = start_time.elapsed().as_secs_f64();
if elapsed > 0.0 {
let speed = downloaded as f64 / elapsed;
let speed_str = Self::format_speed(speed);
pb.set_message(format!("Speed: {}", speed_str));
}
}
}
pub async fn set_downloaded_bytes(&self, bytes: u64) {
*self.downloaded_bytes.lock().await = bytes;
}
pub async fn set_start_time(&self, start_time: Instant) {
*self.start_time.lock().await = Some(start_time);
}
}