use std::{collections::VecDeque, time::Instant}; use gpui::SharedString; use super::JobId; pub struct GitJobDebugQueue {    pending: VecDeque<PendingJob>,    running: VecDeque<RunningJob>,    completed: VecDeque<CompletedJob>,} const MAX_COMPLETED_JOBS: usize = 500; #[derive(Clone, Debug)]pub struct PendingJob {    pub id: JobId,    pub description: SharedString,    pub key: Option<SharedString>,    pub enqueued_at: Instant,} #[derive(Clone, Debug)]pub struct RunningJob {    pub id: JobId,    pub description: SharedString,    pub key: Option<SharedString>,    pub enqueued_at: Instant,    pub started_at: Instant,} #[derive(Clone, Debug)]pub struct CompletedJob {    pub id: JobId,    pub description: SharedString,    pub key: Option<SharedString>,    pub enqueued_at: Instant,    pub started_at: Option<Instant>,    pub completed_at: Instant,    pub status: CompletedJobStatus,} #[derive(Clone, Copy, Debug, PartialEq, Eq)]pub enum CompletedJobStatus {    Finished,    Skipped,} impl GitJobDebugQueue {    pub fn new() -> Self {        Self {            pending: VecDeque::new(),            running: VecDeque::new(),            completed: VecDeque::new(),        }    }     pub fn add(&mut self, id: JobId, description: &'static str, key: Option<SharedString>) {        self.pending.push_back(PendingJob {            id,            description: description.into(),            key,            enqueued_at: Instant::now(),        });    }     pub fn mark_running(&mut self, id: JobId) {        let Some(index) = self.pending.iter().position(|job| job.id == id) else {            return;        };        // Safe to unwrap: `index` was just found by `position()`, so it's in bounds.        let pending = self.pending.remove(index).unwrap();         self.running.push_back(RunningJob {            id: pending.id,            description: pending.description,            key: pending.key,            enqueued_at: pending.enqueued_at,            started_at: Instant::now(),        });    }     pub fn mark_unfinished_complete(&mut self, status: CompletedJobStatus) {        let ids = self            .pending            .iter()            .map(|job| job.id)            .chain(self.running.iter().map(|job| job.id))            .collect::<Vec<_>>();        for id in ids {            self.mark_complete(id, status);        }    }     pub fn mark_complete(&mut self, id: JobId, status: CompletedJobStatus) {        let (enqueued_at, started_at, description, key) =            if let Some(index) = self.running.iter().position(|job| job.id == id) {                let running = self.running.remove(index).unwrap();                (                    running.enqueued_at,                    Some(running.started_at),                    running.description,                    running.key,                )            } else if let Some(index) = self.pending.iter().position(|job| job.id == id) {                let pending = self.pending.remove(index).unwrap();                (pending.enqueued_at, None, pending.description, pending.key)            } else {                return;            };         self.completed.push_back(CompletedJob {            id,            description,            key,            enqueued_at,            started_at,            completed_at: Instant::now(),            status,        });         while self.completed.len() > MAX_COMPLETED_JOBS {            self.completed.pop_front();        }    }     pub fn to_debug_string(&self) -> String {        serde_json::to_string_pretty(&self.to_debug_value()).unwrap_or_default()    }     pub fn to_debug_value(&self) -> serde_json::Value {        let mut entries = Vec::new();         let mut pending_count = 0u64;        let mut running_count = 0u64;        let mut finished_count = 0u64;        let mut skipped_count = 0u64;         for job in &self.pending {            pending_count += 1;            entries.push((job.enqueued_at, self.format_pending(job)));        }        for job in &self.running {            running_count += 1;            entries.push((job.enqueued_at, self.format_running(job)));        }        for job in &self.completed {            match job.status {                CompletedJobStatus::Finished => finished_count += 1,                CompletedJobStatus::Skipped => skipped_count += 1,            }            entries.push((job.enqueued_at, self.format_completed(job)));        }         entries.sort_by_key(|(enqueued_at, _)| *enqueued_at);         let json_entries: Vec<serde_json::Value> =            entries.into_iter().map(|(_, json)| json).collect();         serde_json::json!({            "summary": {                "pending": pending_count,                "running": running_count,                "finished": finished_count,                "skipped": skipped_count,            },            "entries": json_entries,        })    }     fn format_pending(&self, job: &PendingJob) -> serde_json::Value {        serde_json::json!({            "id": job.id,            "description": job.description.as_ref(),            "key": job.key.as_ref().map(|k| k.as_ref()),            "status": "Pending",            "enqueued": format!("{} ago", format_duration(job.enqueued_at.elapsed())),        })    }     fn format_running(&self, job: &RunningJob) -> serde_json::Value {        serde_json::json!({            "id": job.id,            "description": job.description.as_ref(),            "key": job.key.as_ref().map(|k| k.as_ref()),            "status": "Running",            "enqueued": format!("{} ago", format_duration(job.enqueued_at.elapsed())),            "wait_time": format_duration(job.started_at.duration_since(job.enqueued_at)),            "run_time": format!("{} (still running)", format_duration(job.started_at.elapsed())),        })    }     fn format_completed(&self, job: &CompletedJob) -> serde_json::Value {        let status = match job.status {            CompletedJobStatus::Finished => "Finished",            CompletedJobStatus::Skipped => "Skipped",        };         let (wait_time, run_time) = if let Some(started) = job.started_at {            let wait = format_duration(started.duration_since(job.enqueued_at));            let run = format_duration(job.completed_at.duration_since(started));            (wait, Some(run))        } else {            let wait = format!(                "{} (skipped)",                format_duration(job.completed_at.duration_since(job.enqueued_at))            );            (wait, None)        };         serde_json::json!({            "id": job.id,            "description": job.description.as_ref(),            "key": job.key.as_ref().map(|k| k.as_ref()),            "status": status,            "enqueued": format!("{} ago", format_duration(job.enqueued_at.elapsed())),            "wait_time": wait_time,            "run_time": run_time,        })    }} fn format_duration(duration: std::time::Duration) -> String {    let secs = duration.as_secs_f64();    if secs < 0.001 {        format!("{:.0}us", secs * 1_000_000.0)    } else if secs < 1.0 {        format!("{:.0}ms", secs * 1000.0)    } else if secs < 60.0 {        format!("{:.0}s", secs)    } else if secs < 3600.0 {        format!("{:.0}m", secs / 60.0)    } else {        format!("{:.0}h", secs / 3600.0)    }}