veilid-tools 0.5.5

use super::*;

cfg_if! {
    if #[cfg(all(target_arch = "wasm32", target_os = "unknown"))] {
        use js_sys::Date;

        /// Current wall-clock time as microseconds since the Unix epoch.
        #[must_use]
        pub fn get_raw_timestamp() -> u64 {
            if is_browser() {
                (Date::now() * 1000.0f64) as u64
            } else {
                panic!("WASM requires browser environment");
            }
        }

        /// Format a microsecond Unix timestamp as a UTC string, omitting date fields that match the current time.
        #[must_use]
        pub fn human_timestamp(ts: u64) -> String {
            if is_browser() {
                let now = Date::new_0();
                now.set_time(Date::now());
                let date = Date::new_0();
                date.set_time((ts / 1000u64) as f64);

                let show_year = now.get_utc_full_year() != date.get_utc_full_year();
                let show_month = show_year || now.get_utc_month() != date.get_utc_month();
                let show_date = show_month || now.get_utc_date() != date.get_utc_date();

                let s_year = if show_year {
                    format!("{:04}/",date.get_utc_full_year())
                } else {
                    "".to_owned()
                };
                let s_month = if show_month {
                    format!("{:02}/",date.get_utc_month())
                } else {
                    "".to_owned()
                };
                let s_date = if show_date {
                    format!("{:02}-",date.get_utc_date())
                } else {
                    "".to_owned()
                };
                let s_time = format!("{:02}:{:02}:{:02}.{:04}",
                    date.get_utc_hours(),
                    date.get_utc_minutes(),
                    date.get_utc_seconds(),
                    date.get_utc_milliseconds()
                );

                format!("{}{}{}{}",
                    s_year,
                    s_month,
                    s_date,
                    s_time
                )
            } else {
                panic!("WASM requires browser environment");
            }
        }
    } else {
        use std::time::{SystemTime, UNIX_EPOCH};
        use chrono::{Datelike, Timelike};

        /// Current wall-clock time as microseconds since the Unix epoch.
        #[must_use]
        pub fn get_raw_timestamp() -> u64 {
            match SystemTime::now().duration_since(UNIX_EPOCH) {
                Ok(n) => n.as_micros() as u64,
                Err(_) => panic!("SystemTime before UNIX_EPOCH!"),
            }
        }

        /// Format a microsecond Unix timestamp as a UTC string, omitting date fields that match the current time.
        #[must_use]
        pub fn human_timestamp(ts: u64) -> String {
            let now = chrono::DateTime::<chrono::Utc>::from(SystemTime::now());
            let date = chrono::DateTime::<chrono::Utc>::from(UNIX_EPOCH + Duration::from_micros(ts));

            let show_year = now.year() != date.year();
            let show_month = show_year || now.month() != date.month();
            let show_date = show_month || now.day() != date.day();

            let s_year = if show_year {
                format!("{:04}/",date.year())
            } else {
                "".to_owned()
            };
            let s_month = if show_month {
                format!("{:02}/",date.month())
            } else {
                "".to_owned()
            };
            let s_date = if show_date {
                format!("{:02}-",date.day())
            } else {
                "".to_owned()
            };
            let s_time = format!("{:02}:{:02}:{:02}.{:04}",
                date.hour(),
                date.minute(),
                date.second(),
                date.nanosecond()/1_000_000
            );
            format!("{}{}{}{}",
                s_year,
                s_month,
                s_date,
                s_time)
        }
    }
}

const DAY: u64 = 1_000_000u64 * 60 * 60 * 24;
const HOUR: u64 = 1_000_000u64 * 60 * 60;
const MIN: u64 = 1_000_000u64 * 60;
const SEC: u64 = 1_000_000u64;
const MSEC: u64 = 1_000u64;

/// Format a microsecond duration as a human-readable string, e.g. `1d2h3m4.005s` or `1.005ms`.
#[must_use]
pub fn human_duration(dur: u64) -> String {
    let days = dur / DAY;
    let dur = dur % DAY;
    let hours = dur / HOUR;
    let dur = dur % HOUR;
    let mins = dur / MIN;
    let dur = dur % MIN;
    let secs = dur / SEC;
    let dur = dur % SEC;
    let msecs = dur / MSEC;
    let dur = dur % MSEC;

    // microseconds format
    if days == 0 && hours == 0 && mins == 0 && secs == 0 {
        format!("{}.{:03}ms", msecs, dur)
    } else {
        format!(
            "{}{}{}{}.{:03}s",
            if days != 0 {
                format!("{}d", days)
            } else {
                "".to_owned()
            },
            if hours != 0 {
                format!("{}h", hours)
            } else {
                "".to_owned()
            },
            if mins != 0 {
                format!("{}m", mins)
            } else {
                "".to_owned()
            },
            secs,
            msecs
        )
    }
}

/// Parse a duration string with `h`/`m`/`s` suffixes into microseconds; returns `None` on any unexpected character.
#[must_use]
pub fn parse_duration(s: &str) -> Option<u64> {
    let mut dur_total: u64 = 0;
    let mut dur: u64 = 0;
    for c in s.as_bytes() {
        match c {
            b'0'..=b'9' => {
                dur *= 10;
                dur += (c - b'0') as u64;
            }
            b'h' => {
                dur *= 3_600_000u64;
                dur_total += dur;
                dur = 0;
            }
            b'm' => {
                dur *= 60_000u64;
                dur_total += dur;
                dur = 0;
            }
            b's' => {
                dur *= 1_000u64;
                dur_total += dur;
                dur = 0;
            }
            _ => return None,
        }
    }
    dur_total += dur;
    Some(dur_total * 1_000u64)
}