aix-rs 1.0.0

Manage AI gateway profiles and launch AI coding tools with the right credentials
use crate::cli::UsageRangeArgs;
use crate::error::AixError;
use chrono::{Days, Local, NaiveDate};

#[derive(Clone, Copy)]
pub(super) struct UsageRange {
    pub(super) start: NaiveDate,
    pub(super) end: NaiveDate,
}

impl UsageRange {
    pub(super) fn from_args(args: &UsageRangeArgs, today: NaiveDate) -> Result<Self, AixError> {
        let since = args.since.as_deref();
        let start = args.start.as_deref();
        let end = args.end.as_deref();

        if since.is_some() && (start.is_some() || end.is_some()) {
            return Err(invalid_range(
                "--since cannot be combined with --start or --end",
            ));
        }

        match (since, start, end) {
            (Some(since), None, None) => {
                let days = parse_since(since)?;
                let start = today
                    .checked_sub_days(Days::new(days - 1))
                    .ok_or_else(|| invalid_range("the requested --since range is too large"))?;
                Ok(Self { start, end: today })
            }
            (None, Some(start), Some(end)) => {
                let start = parse_iso_date(start)?;
                let end = parse_iso_date(end)?;
                if end < start {
                    return Err(invalid_range("--end must be on or after --start"));
                }
                Ok(Self { start, end })
            }
            (None, None, None) => {
                let start = today
                    .checked_sub_days(Days::new(29))
                    .ok_or_else(|| invalid_range("the default 30-day range is out of bounds"))?;
                Ok(Self { start, end: today })
            }
            (None, _, _) => Err(invalid_range("--start and --end must be provided together")),
            (Some(_), _, _) => Err(invalid_range(
                "--since cannot be combined with --start or --end",
            )),
        }
    }

    pub(super) fn local_unix_millis_bounds(self) -> Result<(u64, u64), AixError> {
        let start = local_midnight(self.start)?.timestamp_millis();
        let next_day = self
            .end
            .checked_add_days(Days::new(1))
            .ok_or_else(|| invalid_range("the requested date range is out of bounds"))?;
        let end_exclusive = local_midnight(next_day)?.timestamp_millis();
        let end_inclusive = end_exclusive.saturating_sub(1);

        if end_inclusive < 0 {
            return Ok((1, 0));
        }
        Ok((start.max(0) as u64, end_inclusive as u64))
    }
}

fn local_midnight(date: NaiveDate) -> Result<chrono::DateTime<Local>, AixError> {
    date.and_hms_opt(0, 0, 0)
        .and_then(|datetime| {
            datetime
                .and_local_timezone(Local)
                .earliest()
                .or_else(|| datetime.and_local_timezone(Local).latest())
        })
        .ok_or_else(|| invalid_range("a date boundary cannot be represented in the local timezone"))
}

fn parse_since(value: &str) -> Result<u64, AixError> {
    let Some(days) = value.strip_suffix('d') else {
        return Err(invalid_range(
            "--since must be a positive whole-day duration such as 7d",
        ));
    };
    if days.is_empty() || !days.bytes().all(|byte| byte.is_ascii_digit()) {
        return Err(invalid_range(
            "--since must be a positive whole-day duration such as 7d",
        ));
    }
    let days = days
        .parse::<u64>()
        .map_err(|_| invalid_range("--since day count is too large"))?;
    if days == 0 {
        return Err(invalid_range("--since must be greater than 0d"));
    }
    Ok(days)
}

fn parse_iso_date(value: &str) -> Result<NaiveDate, AixError> {
    let date = NaiveDate::parse_from_str(value, "%Y-%m-%d")
        .map_err(|_| invalid_range("dates must use the inclusive YYYY-MM-DD format"))?;
    if date.format("%Y-%m-%d").to_string() != value {
        return Err(invalid_range(
            "dates must use the inclusive YYYY-MM-DD format",
        ));
    }
    Ok(date)
}

fn invalid_range(reason: &str) -> AixError {
    AixError::InvalidUsageRange {
        reason: reason.to_string(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn fixed_today() -> NaiveDate {
        NaiveDate::from_ymd_opt(2026, 9, 30).unwrap()
    }

    #[test]
    fn default_range_is_thirty_calendar_days_including_today() {
        let range = UsageRange::from_args(&UsageRangeArgs::default(), fixed_today()).unwrap();
        assert_eq!(range.start.format("%Y-%m-%d").to_string(), "2026-09-01");
        assert_eq!(range.end.format("%Y-%m-%d").to_string(), "2026-09-30");
    }

    #[test]
    fn since_range_counts_calendar_days_including_today() {
        let args = UsageRangeArgs {
            since: Some("7d".to_string()),
            ..UsageRangeArgs::default()
        };
        let range = UsageRange::from_args(&args, fixed_today()).unwrap();
        assert_eq!(range.start.format("%Y-%m-%d").to_string(), "2026-09-24");
        assert_eq!(range.end.format("%Y-%m-%d").to_string(), "2026-09-30");
    }

    #[test]
    fn explicit_dates_are_inclusive_and_iso_formatted() {
        let args = UsageRangeArgs {
            start: Some("2026-09-01".to_string()),
            end: Some("2026-09-30".to_string()),
            ..UsageRangeArgs::default()
        };
        let range = UsageRange::from_args(&args, fixed_today()).unwrap();
        assert_eq!(range.start.format("%Y-%m-%d").to_string(), "2026-09-01");
        assert_eq!(range.end.format("%Y-%m-%d").to_string(), "2026-09-30");
    }

    #[test]
    fn date_range_rejects_invalid_durations_dates_and_conflicts() {
        for value in ["0d", "7", "-1d", "1.5d", "7D", "18446744073709551616d"] {
            let args = UsageRangeArgs {
                since: Some(value.to_string()),
                ..UsageRangeArgs::default()
            };
            assert!(UsageRange::from_args(&args, fixed_today()).is_err());
        }

        let invalid_date = UsageRangeArgs {
            start: Some("2026-9-01".to_string()),
            end: Some("2026-09-02".to_string()),
            ..UsageRangeArgs::default()
        };
        assert!(UsageRange::from_args(&invalid_date, fixed_today()).is_err());

        let reversed = UsageRangeArgs {
            start: Some("2026-09-02".to_string()),
            end: Some("2026-09-01".to_string()),
            ..UsageRangeArgs::default()
        };
        assert!(UsageRange::from_args(&reversed, fixed_today()).is_err());

        let missing_end = UsageRangeArgs {
            start: Some("2026-09-01".to_string()),
            ..UsageRangeArgs::default()
        };
        assert!(UsageRange::from_args(&missing_end, fixed_today()).is_err());

        let conflict = UsageRangeArgs {
            since: Some("7d".to_string()),
            start: Some("2026-09-01".to_string()),
            end: Some("2026-09-02".to_string()),
        };
        assert!(UsageRange::from_args(&conflict, fixed_today()).is_err());
    }
}