magi-code 0.96.1

#[cfg(any(test, debug_assertions))]
mod active {
    use std::{
        cell::{Cell, RefCell},
        env,
        time::Instant,
    };

    #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
    pub(crate) struct TuiPerfSnapshot {
        pub(crate) frame: u64,
        pub(crate) last_drain_us: u64,
        pub(crate) max_drain_us: u64,
        pub(crate) last_draw_us: u64,
        pub(crate) max_draw_us: u64,
        pub(crate) last_prompt_edit_to_draw_us: u64,
        /// Mouse-scroll batches applied since the previous successful draw.
        pub(crate) scroll_batches: u64,
        pub(crate) scroll_input_backlog: usize,
        /// Earliest applied batch through successful terminal draw; not display latency.
        pub(crate) scroll_apply_to_draw_us: Option<u64>,
        pub(crate) projected_cards: usize,
        pub(crate) backlog_before_drain: usize,
        pub(crate) backlog_after_drain: usize,
        pub(crate) backlog_before_draw: usize,
    }

    #[derive(Debug, Default)]
    pub(crate) struct TuiPerfCounters {
        enabled: Cell<bool>,
        frame: Cell<u64>,
        last_drain_us: Cell<u64>,
        max_drain_us: Cell<u64>,
        last_draw_us: Cell<u64>,
        max_draw_us: Cell<u64>,
        last_prompt_edit_to_draw_us: Cell<u64>,
        pending_scroll_started: Cell<Option<Instant>>,
        pending_scroll_batches: Cell<u64>,
        pending_scroll_input_backlog: Cell<usize>,
        projected_cards: Cell<usize>,
        backlog_before_drain: Cell<usize>,
        backlog_after_drain: Cell<usize>,
        backlog_before_draw: Cell<usize>,
        latest_snapshot: RefCell<Option<TuiPerfSnapshot>>,
    }

    impl TuiPerfCounters {
        pub(crate) fn from_env() -> Self {
            Self::with_enabled(env_enabled())
        }

        pub(crate) fn with_enabled(enabled: bool) -> Self {
            Self {
                enabled: Cell::new(enabled),
                ..Default::default()
            }
        }

        pub(crate) fn enabled(&self) -> bool {
            self.enabled.get()
        }

        pub(crate) fn set_backlog_before_drain(&self, backlog: usize) {
            if self.enabled() {
                self.backlog_before_drain.set(backlog);
            }
        }

        pub(crate) fn set_backlog_after_drain(&self, backlog: usize) {
            if self.enabled() {
                self.backlog_after_drain.set(backlog);
            }
        }

        pub(crate) fn set_backlog_before_draw(&self, backlog: usize) {
            if self.enabled() {
                self.backlog_before_draw.set(backlog);
            }
        }

        pub(crate) fn record_drain_us(&self, elapsed_us: u64) {
            if !self.enabled() {
                return;
            }
            self.last_drain_us.set(elapsed_us);
            self.max_drain_us
                .set(self.max_drain_us.get().max(elapsed_us));
        }

        pub(crate) fn reset_projected_cards(&self) {
            if self.enabled() {
                self.projected_cards.set(0);
            }
        }

        pub(crate) fn increment_projected_cards(&self) {
            if self.enabled() {
                self.projected_cards
                    .set(self.projected_cards.get().saturating_add(1));
            }
        }

        /// Called only for changed mouse-scroll commands. Input events have no capture
        /// timestamp, so queue depth is recorded rather than claiming queue latency.
        pub(crate) fn record_scroll_applied(&self, started: Instant, input_backlog: usize) {
            if !self.enabled() {
                return;
            }
            self.pending_scroll_started.set(Some(
                self.pending_scroll_started
                    .get()
                    .map_or(started, |first| first.min(started)),
            ));
            self.pending_scroll_batches
                .set(self.pending_scroll_batches.get().saturating_add(1));
            self.pending_scroll_input_backlog
                .set(self.pending_scroll_input_backlog.get().max(input_backlog));
        }

        pub(crate) fn record_draw_us(&self, elapsed_us: u64) {
            if !self.enabled() {
                return;
            }
            self.last_draw_us.set(elapsed_us);
            self.max_draw_us.set(self.max_draw_us.get().max(elapsed_us));
            self.frame.set(self.frame.get().saturating_add(1));
            let snapshot = TuiPerfSnapshot {
                frame: self.frame.get(),
                last_drain_us: self.last_drain_us.get(),
                max_drain_us: self.max_drain_us.get(),
                last_draw_us: self.last_draw_us.get(),
                max_draw_us: self.max_draw_us.get(),
                last_prompt_edit_to_draw_us: self.last_prompt_edit_to_draw_us.get(),
                scroll_batches: self.pending_scroll_batches.replace(0),
                scroll_input_backlog: self.pending_scroll_input_backlog.replace(0),
                scroll_apply_to_draw_us: self
                    .pending_scroll_started
                    .take()
                    .map(|started| started.elapsed().as_micros().min(u64::MAX as u128) as u64),
                projected_cards: self.projected_cards.get(),
                backlog_before_drain: self.backlog_before_drain.get(),
                backlog_after_drain: self.backlog_after_drain.get(),
                backlog_before_draw: self.backlog_before_draw.get(),
            };
            *self.latest_snapshot.borrow_mut() = Some(snapshot);
        }
        pub(crate) fn record_prompt_edit_to_draw_us(&self, elapsed_us: u64) {
            if !self.enabled() {
                return;
            }
            self.last_prompt_edit_to_draw_us.set(elapsed_us);
            if let Some(snapshot) = self.latest_snapshot.borrow_mut().as_mut() {
                snapshot.last_prompt_edit_to_draw_us = elapsed_us;
            }
        }

        pub(crate) fn latest_snapshot(&self) -> Option<TuiPerfSnapshot> {
            *self.latest_snapshot.borrow()
        }

        pub(crate) fn footer_text(&self) -> Option<String> {
            let snapshot = self.latest_snapshot()?;
            // Keep scroll measurements visible even when the debug footer is clipped.
            let scroll = snapshot
                .scroll_apply_to_draw_us
                .map_or_else(String::new, |us| {
                    format!(
                        "scroll->draw {:.1}ms batches {} input-backlog {} | ",
                        micros_to_millis(us),
                        snapshot.scroll_batches,
                        snapshot.scroll_input_backlog,
                    )
                });
            Some(format!(
                "{scroll}perf drain {:.1}/{:.1}ms draw {:.1}/{:.1}ms cards {} backlog {}/{}/{} edit->draw {:.1}ms",
                micros_to_millis(snapshot.last_drain_us),
                micros_to_millis(snapshot.max_drain_us),
                micros_to_millis(snapshot.last_draw_us),
                micros_to_millis(snapshot.max_draw_us),
                snapshot.projected_cards,
                snapshot.backlog_before_drain,
                snapshot.backlog_after_drain,
                snapshot.backlog_before_draw,
                micros_to_millis(snapshot.last_prompt_edit_to_draw_us),
            ))
        }
    }

    fn micros_to_millis(value: u64) -> f64 {
        value as f64 / 1000.0
    }

    fn env_enabled() -> bool {
        env_flag_enabled("MAGI_TUI_PERF") || env_flag_enabled("MC_TUI_PERF")
    }

    fn env_flag_enabled(name: &str) -> bool {
        env::var_os(name).is_some_and(|value| value == "1")
    }
}

#[cfg(not(any(test, debug_assertions)))]
mod release {
    #[inline(always)]
    pub(crate) fn increment_projected_cards() {}
}

#[cfg(any(test, debug_assertions))]
pub(crate) use active::*;
#[cfg(not(any(test, debug_assertions)))]
pub(crate) use release::*;