rosetta_date/

timezone.rs

//! Timezone handling: abbreviation mapping, offset parsing, and conversion.

use crate::error::{Result, RosettaError};

/// A resolved timezone offset in seconds from UTC.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TzOffset {
    /// Total offset from UTC in seconds (e.g. +28800 for UTC+8).
    pub total_seconds: i32,
}

impl TzOffset {
    pub const UTC: TzOffset = TzOffset { total_seconds: 0 };

    pub fn from_hm(hours: i32, minutes: i32) -> Self {
        Self {
            total_seconds: hours * 3600 + minutes.signum() * minutes.abs() * 60,
        }
    }

    pub fn hours(&self) -> i32 {
        self.total_seconds / 3600
    }

    pub fn minutes(&self) -> i32 {
        (self.total_seconds % 3600) / 60
    }
}

impl std::fmt::Display for TzOffset {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let sign = if self.total_seconds >= 0 { '+' } else { '-' };
        let abs = self.total_seconds.unsigned_abs();
        let h = abs / 3600;
        let m = (abs % 3600) / 60;
        write!(f, "{}{:02}:{:02}", sign, h, m)
    }
}

/// Common timezone abbreviation → offset mapping.
/// Note: some abbreviations are ambiguous; we pick the most common interpretation.
static TZ_ABBREVIATIONS: &[(&str, i32)] = &[
    // UTC variants
    ("utc", 0),
    ("gmt", 0),
    ("z", 0),
    // North America
    ("est", -5 * 3600),
    ("edt", -4 * 3600),
    ("cst", -6 * 3600),
    ("cdt", -5 * 3600),
    ("mst", -7 * 3600),
    ("mdt", -6 * 3600),
    ("pst", -8 * 3600),
    ("pdt", -7 * 3600),
    ("akst", -9 * 3600),
    ("akdt", -8 * 3600),
    ("hst", -10 * 3600),
    // Europe
    ("wet", 0),
    ("west", 3600),
    ("cet", 3600),
    ("cest", 2 * 3600),
    ("eet", 2 * 3600),
    ("eest", 3 * 3600),
    ("msk", 3 * 3600),
    // Asia
    ("ist", 5 * 3600 + 1800), // India
    ("pkt", 5 * 3600),        // Pakistan
    ("bst", 6 * 3600),        // Bangladesh
    ("ict", 7 * 3600),        // Indochina
    ("cst_cn", 8 * 3600),     // China
    ("hkt", 8 * 3600),        // Hong Kong
    ("sgt", 8 * 3600),        // Singapore
    ("kst", 9 * 3600),        // Korea
    ("jst", 9 * 3600),        // Japan
    // Oceania
    ("awst", 8 * 3600),
    ("acst", 9 * 3600 + 1800),
    ("aest", 10 * 3600),
    ("nzst", 12 * 3600),
    ("nzdt", 13 * 3600),
];

/// IANA-style timezone name → offset mapping (a subset of common ones).
static IANA_ZONES: &[(&str, i32)] = &[
    ("asia/shanghai", 8 * 3600),
    ("asia/hong_kong", 8 * 3600),
    ("asia/tokyo", 9 * 3600),
    ("asia/seoul", 9 * 3600),
    ("asia/kolkata", 5 * 3600 + 1800),
    ("asia/singapore", 8 * 3600),
    ("asia/dubai", 4 * 3600),
    ("europe/london", 0),
    ("europe/paris", 3600),
    ("europe/berlin", 3600),
    ("europe/moscow", 3 * 3600),
    ("america/new_york", -5 * 3600),
    ("america/chicago", -6 * 3600),
    ("america/denver", -7 * 3600),
    ("america/los_angeles", -8 * 3600),
    ("america/sao_paulo", -3 * 3600),
    ("pacific/auckland", 12 * 3600),
    ("australia/sydney", 10 * 3600),
];

/// Parse a timezone string and return the offset.
///
/// Supports:
/// - Abbreviations: "UTC", "PST", "JST", etc.
/// - IANA names: "Asia/Shanghai", "America/New_York"
/// - Numeric offsets: "+0800", "+08:00", "-07:00", "+08", "Z"
pub fn parse_timezone(input: &str) -> Result<TzOffset> {
    let trimmed = input.trim();

    // "Z" → UTC
    if trimmed.eq_ignore_ascii_case("z") {
        return Ok(TzOffset::UTC);
    }

    // Try numeric offset: +0800, +08:00, -07, etc.
    if let Some(offset) = try_parse_numeric_offset(trimmed) {
        return Ok(offset);
    }

    let lower = trimmed.to_lowercase();

    // Try abbreviation
    for &(abbr, secs) in TZ_ABBREVIATIONS {
        if lower == abbr {
            return Ok(TzOffset {
                total_seconds: secs,
            });
        }
    }

    // Try IANA name (normalize separators)
    let normalized = lower.replace(' ', "_").replace("//", "/");
    for &(name, secs) in IANA_ZONES {
        if normalized == name {
            return Ok(TzOffset {
                total_seconds: secs,
            });
        }
    }

    Err(RosettaError::TimezoneError(format!(
        "Unknown timezone: '{}'",
        trimmed
    )))
}

/// Try to parse a numeric offset string like "+0800", "+08:00", "-07", "+08".
fn try_parse_numeric_offset(s: &str) -> Option<TzOffset> {
    let bytes = s.as_bytes();
    if bytes.is_empty() {
        return None;
    }

    let (sign, rest) = match bytes[0] {
        b'+' => (1i32, &s[1..]),
        b'-' => (-1i32, &s[1..]),
        _ => return None,
    };

    // Remove optional colon: "+08:00" → "0800"
    let digits: String = rest.chars().filter(|c| c.is_ascii_digit()).collect();

    let (hours, minutes) = match digits.len() {
        1 | 2 => {
            // "+8" or "+08"
            let h: i32 = digits.parse().ok()?;
            (h, 0)
        }
        3 => {
            // "+830" → 8h 30m
            let h: i32 = digits[..1].parse().ok()?;
            let m: i32 = digits[1..].parse().ok()?;
            (h, m)
        }
        4 => {
            // "+0800"
            let h: i32 = digits[..2].parse().ok()?;
            let m: i32 = digits[2..].parse().ok()?;
            (h, m)
        }
        _ => return None,
    };

    if hours > 14 || minutes > 59 {
        return None;
    }

    Some(TzOffset {
        total_seconds: sign * (hours * 3600 + minutes * 60),
    })
}

/// Try to extract a timezone offset from the tail of a date string.
/// Returns `(remaining_input, offset)` if found.
pub fn extract_trailing_timezone(input: &str) -> Option<(&str, TzOffset)> {
    let trimmed = input.trim_end();

    // Try "Z" at end
    if trimmed.ends_with('Z') || trimmed.ends_with('z') {
        let rest = &trimmed[..trimmed.len() - 1];
        return Some((rest.trim_end(), TzOffset::UTC));
    }

    // Try numeric offset at end: "+08:00", "+0800", "-07:00"
    // Look for the last '+' or '-' that could start an offset
    for search_len in [6, 5, 3, 2] {
        if trimmed.len() > search_len && trimmed.is_char_boundary(trimmed.len() - search_len) {
            let tail = &trimmed[trimmed.len() - search_len..];
            // Only consider it an offset if the preceding char is a space, 'T', or 't'
            // (prevents mismatching date components like "-10-15" as offsets)
            let preceding_idx = trimmed.len() - search_len;
            let preceding_ok = if preceding_idx == 0 {
                true
            } else {
                let prev = trimmed.as_bytes()[preceding_idx - 1];
                // Always allow space/T. For '+', allow after digits too
                // ('+' is unambiguous, only '-' can be confused with date separators)
                let starts_with_plus = tail.starts_with('+');
                prev == b' '
                    || prev == b'T'
                    || prev == b't'
                    || (starts_with_plus && prev.is_ascii_digit())
            };
            if preceding_ok && let Some(offset) = try_parse_numeric_offset(tail) {
                let rest = &trimmed[..trimmed.len() - search_len];
                return Some((rest.trim_end(), offset));
            }
        }
    }

    // Try abbreviation at end (split on last space)
    if let Some(last_space) = trimmed.rfind(' ') {
        let tail = &trimmed[last_space + 1..];
        if let Ok(offset) = parse_timezone(tail) {
            let rest = &trimmed[..last_space];
            return Some((rest.trim_end(), offset));
        }
    }

    None
}

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

    #[test]
    fn test_parse_utc() {
        assert_eq!(parse_timezone("UTC").unwrap().total_seconds, 0);
        assert_eq!(parse_timezone("Z").unwrap().total_seconds, 0);
        assert_eq!(parse_timezone("gmt").unwrap().total_seconds, 0);
    }

    #[test]
    fn test_parse_numeric_offsets() {
        assert_eq!(parse_timezone("+08:00").unwrap().total_seconds, 28800);
        assert_eq!(parse_timezone("+0800").unwrap().total_seconds, 28800);
        assert_eq!(parse_timezone("-05:00").unwrap().total_seconds, -18000);
        assert_eq!(parse_timezone("+08").unwrap().total_seconds, 28800);
    }

    #[test]
    fn test_parse_abbreviations() {
        assert_eq!(parse_timezone("PST").unwrap().total_seconds, -28800);
        assert_eq!(parse_timezone("JST").unwrap().total_seconds, 32400);
        assert_eq!(parse_timezone("EST").unwrap().total_seconds, -18000);
    }

    #[test]
    fn test_parse_iana() {
        assert_eq!(
            parse_timezone("Asia/Shanghai").unwrap().total_seconds,
            28800
        );
        assert_eq!(
            parse_timezone("America/New_York").unwrap().total_seconds,
            -18000
        );
    }

    #[test]
    fn test_extract_trailing_tz() {
        let (rest, tz) = extract_trailing_timezone("2023-10-01 12:30:00+08:00").unwrap();
        assert_eq!(rest, "2023-10-01 12:30:00");
        assert_eq!(tz.total_seconds, 28800);

        let (rest, tz) = extract_trailing_timezone("2023-10-01 12:30:00Z").unwrap();
        assert_eq!(rest, "2023-10-01 12:30:00");
        assert_eq!(tz.total_seconds, 0);

        let (rest, tz) = extract_trailing_timezone("2023-10-01 12:30:00 PST").unwrap();
        assert_eq!(rest, "2023-10-01 12:30:00");
        assert_eq!(tz.total_seconds, -28800);
    }

    #[test]
    fn test_tz_display() {
        assert_eq!(format!("{}", TzOffset::from_hm(8, 0)), "+08:00");
        assert_eq!(format!("{}", TzOffset::from_hm(-5, 0)), "-05:00");
        assert_eq!(format!("{}", TzOffset::UTC), "+00:00");
    }
}