rosetta_date/

dateparser.rs

//! Extended format parser inspired by the `dateparser` crate
//! (<https://github.com/waltzofpearls/dateparser>).
//!
//! Handles Unix timestamps, Postgres-style datetimes, slash/dot separated
//! dates, abbreviated/full month names, AM/PM, MySQL log format, Chinese
//! date literals, and time-only inputs.

use crate::datetime::RosettaDateTime;
use crate::error::{Result, RosettaError};
use crate::timezone::{self, TzOffset};

// ── Public entry point ────────────────────────────────────────────────

pub(crate) fn try_parse(input: &str, default_tz: &TzOffset) -> Result<RosettaDateTime> {
    let s = input.trim();

    // 1. Unix timestamp (all digits, optional leading '-')
    if let Some(dt) = try_unix_timestamp(s) {
        return Ok(dt);
    }

    // 2. Chinese date literals: 2014年04月08日…
    if let Some(dt) = try_chinese_format(s, default_tz) {
        return Ok(dt);
    }

    // 3. MySQL log: 171113 14:14:20
    if let Some(dt) = try_mysql_log(s, default_tz) {
        return Ok(dt);
    }

    // 4. Postgres-style offset right-glued to time with no space: 08:08-08
    // (handled inside try_normalized_heuristic via extract_trailing_timezone)

    // 5. General heuristic that normalises the string and dispatches to
    //    sub-parsers (month names, slash dates, dot dates, AM/PM, time-only…)
    if let Some(dt) = try_normalized(s, default_tz) {
        return Ok(dt);
    }

    Err(RosettaError::ParseError(
        "No dateparser format matched".into(),
    ))
}

// ── Unix timestamps ───────────────────────────────────────────────────

fn try_unix_timestamp(input: &str) -> Option<RosettaDateTime> {
    // Accept strings of only ASCII digits (no sign for now – negative
    // timestamps are exotic and conflict with date separators).
    if input.is_empty() || !input.bytes().all(|b| b.is_ascii_digit()) {
        return None;
    }

    let len = input.len();
    let val: i64 = input.parse().ok()?;

    let seconds = if len <= 10 {
        // seconds
        val
    } else if len <= 13 {
        // milliseconds
        val / 1_000
    } else if len <= 19 {
        // microseconds or nanoseconds
        val / 1_000_000_000
    } else {
        return None;
    };

    let base = RosettaDateTime::from_components(1970, 1, 1, 0, 0, 0, TzOffset::UTC).ok()?;
    Some(base.add_seconds(seconds))
}

// ── Chinese date literals ─────────────────────────────────────────────

fn try_chinese_format(input: &str, default_tz: &TzOffset) -> Option<RosettaDateTime> {
    if !input.contains('年') {
        return None;
    }
    // 2014年04月08日11时25分18秒  /  2014年04月08日
    let s = input
        .replace(['年', '月'], "-")
        .replace('日', " ")
        .replace(['时', '分'], ":")
        .replace('秒', "");

    parse_ymd_hms(s.trim(), default_tz)
}

// ── MySQL log format: yymmdd hh:mm:ss ────────────────────────────────

fn try_mysql_log(input: &str, default_tz: &TzOffset) -> Option<RosettaDateTime> {
    // Exactly "YYMMDD HH:MM:SS" — 6-digit date followed by a space then time
    let parts: Vec<&str> = input.splitn(2, ' ').collect();
    if parts.len() != 2 {
        return None;
    }
    let date_part = parts[0];
    let time_part = parts[1];

    if date_part.len() != 6 || !date_part.bytes().all(|b| b.is_ascii_digit()) {
        return None;
    }

    let yy: i32 = date_part[..2].parse().ok()?;
    let mm: u8 = date_part[2..4].parse().ok()?;
    let dd: u8 = date_part[4..6].parse().ok()?;
    let year = if yy < 70 { 2000 + yy } else { 1900 + yy };

    let (h, min, s) = parse_time_str(time_part)?;
    RosettaDateTime::from_components(year, mm, dd, h, min, s, *default_tz).ok()
}

// ── General normalised heuristic ──────────────────────────────────────

fn try_normalized(input: &str, default_tz: &TzOffset) -> Option<RosettaDateTime> {
    // Postgres-style: "2019-11-29 08:08-08" or "2021-05-02 23:31:36.0741-07"
    // The offset is glued right after digits with no space. Pre-process it by
    // scanning the time part for a ±NN offset.
    let postgres_split = split_postgres_offset(input);
    let (input_for_tz, extra_offset): (&str, Option<TzOffset>) = match &postgres_split {
        Some((body_str, off)) => (body_str.as_str(), Some(*off)),
        None => (input, None),
    };

    // Strip trailing timezone first so the remainder is "clean"
    let (body, offset) = if let Some(off) = extra_offset {
        (input_for_tz, off)
    } else {
        timezone::extract_trailing_timezone(input_for_tz).unwrap_or((input_for_tz, *default_tz))
    };
    let body = body.trim();

    // Detect if first token looks like a month name → month-name-led format
    let first_tok: &str = body.split_whitespace().next().unwrap_or("");
    if month_from_name(first_tok).is_some() {
        return try_month_name_first(body, &offset);
    }

    // Detect if first token is a 1-2 digit day followed by a month name
    // e.g. "12 Feb 2006" / "7 oct 70"
    let toks: Vec<&str> = body.split_whitespace().collect();
    if toks.len() >= 2 {
        let maybe_day: bool = toks[0].parse::<u8>().is_ok();
        let maybe_month: bool = month_from_name(toks[1]).is_some();
        if maybe_day && maybe_month {
            return try_day_month_year(body, &offset);
        }
    }

    // Time-only: "01:06:06", "4:00pm"
    if looks_like_time_only(body) {
        return try_time_only(body, default_tz, &offset);
    }

    // Normalise "/" and "." separators to "-" then try standard-ish parsing
    let normalised = normalise_separators(body);
    parse_ymd_hms(normalised.trim(), &offset)
}

// ── Month-name-first formats ──────────────────────────────────────────
// "May 6 at 9:24 PM", "May 8, 2009 5:57:51 PM", "September 17, 2012, 10:10:09"
// "May 25, 2021", "oct 7, 1970", "2021-Feb-21" (handled in parse_ymd_hms via
//  normalise_separators → month name in middle position)

fn try_month_name_first(body: &str, offset: &TzOffset) -> Option<RosettaDateTime> {
    // Flatten commas and "at" to spaces, then split into tokens
    let cleaned = body.replace(',', " ").replace(" at ", " ").to_lowercase();
    let toks: Vec<&str> = cleaned.split_whitespace().collect();
    if toks.is_empty() {
        return None;
    }

    let month = month_from_name(toks[0])?;

    match toks.len() {
        // "May 25 2021" or "May 6 9:24 PM" (after "at" removal)
        n if n >= 2 => {
            // Second token: day (possibly followed by ordinal suffix stripped already)
            let day_str = strip_ordinal(toks[1]);
            if let Ok(day) = day_str.parse::<u8>() {
                // Third token might be year or time
                if n == 2 {
                    // "oct 7 70" – no year → use current year? But PLAN has "oct 7, 1970"
                    // Minimal: just date
                    let year = default_year();
                    return RosettaDateTime::from_components(year, month, day, 0, 0, 0, *offset)
                        .ok();
                }
                // Could be year first, then optional time
                // or time first then year
                let third = toks[2];
                if let Ok(year) = expand_year(third) {
                    // Year then optional time: "May 8, 2009 5:57:51 PM"
                    let (h, m, s, _ampm) = parse_time_tokens(&toks[3..]);
                    return RosettaDateTime::from_components(year, month, day, h, m, s, *offset)
                        .ok();
                } else if third.contains(':') || third.ends_with("am") || third.ends_with("pm") {
                    // Time first, no year: "May 6 9:24 PM" (year unknown)
                    let (hr, m, s, _am_pm) = parse_time_tokens(&toks[2..]);
                    let year = default_year();
                    return RosettaDateTime::from_components(year, month, day, hr, m, s, *offset)
                        .ok();
                }
            }
            // Fallback: try "oct 7, 70" where third is 2-digit year
            if let Some(day_val) = toks
                .get(1)
                .and_then(|t| strip_ordinal(t).parse::<u8>().ok())
                && let Some(yr_str) = toks.get(2)
                && let Ok(yr) = expand_year(yr_str)
            {
                return RosettaDateTime::from_components(yr, month, day_val, 0, 0, 0, *offset).ok();
            }
            None
        }
        _ => None,
    }
}

/// Parse "7 oct 70", "12 Feb 2006, 19:17", "14 May 2019 19:11:40.164", etc.
fn try_day_month_year(body: &str, offset: &TzOffset) -> Option<RosettaDateTime> {
    let cleaned = body.replace(',', " ").to_lowercase();
    let toks: Vec<&str> = cleaned.split_whitespace().collect();

    let day: u8 = toks.first()?.parse().ok()?;
    let month = month_from_name(toks.get(1)?)?;
    let year = expand_year(toks.get(2)?).ok()?;

    let (h, m, s, _) = parse_time_tokens(toks.get(3..).unwrap_or(&[]));
    RosettaDateTime::from_components(year, month, day, h, m, s, *offset).ok()
}

// ── Time-only ─────────────────────────────────────────────────────────

fn looks_like_time_only(s: &str) -> bool {
    // "01:06:06", "4:00pm", "6:00 AM"
    let first = s.split_whitespace().next().unwrap_or(s);
    let lower = first.to_lowercase();
    let base = lower.trim_end_matches("am").trim_end_matches("pm");
    base.contains(':')
        && !base.contains('-')
        && !base.contains('/')
        && base
            .split(':')
            .next()
            .map(|p| p.len() <= 2)
            .unwrap_or(false)
        && s.split_whitespace()
            .next()
            .map(|p| {
                p.chars()
                    .next()
                    .map(|c| c.is_ascii_digit())
                    .unwrap_or(false)
            })
            .unwrap_or(false)
}

fn try_time_only(body: &str, _default_tz: &TzOffset, offset: &TzOffset) -> Option<RosettaDateTime> {
    let toks: Vec<&str> = body.split_whitespace().collect();
    let (h, m, s, _) = parse_time_tokens(&toks);
    let today = RosettaDateTime::now_utc();
    RosettaDateTime::from_components(today.year(), today.month(), today.day(), h, m, s, *offset)
        .ok()
}

// ── YMD + HMS core parser (after normalisation) ───────────────────────
// Handles "yyyy-mm-dd", "yyyy-mm-dd hh:mm:ss[.frac]",
// "2021-Feb-21" (after normalise_separators makes it "2021-Feb-21")

fn parse_ymd_hms(s: &str, offset: &TzOffset) -> Option<RosettaDateTime> {
    // Split on whitespace; first part is date, optional second part is time
    let mut parts = s.splitn(3, ' ');
    let date_str = parts.next()?;
    let time_str = parts.next(); // may be None

    // Split date on '-'
    let date_segs: Vec<&str> = date_str.split('-').collect();

    let (year, month, day) = match date_segs.len() {
        3 => {
            let (y, m, d) = parse_date_segments(&date_segs)?;
            (y, m, d)
        }
        2 => {
            // "2014.03" → month-only, day=1
            let y: i32 = date_segs[0].parse().ok()?;
            let m: u8 = date_segs[1].parse().ok()?;
            (y, m, 1u8)
        }
        _ => return None,
    };

    let (h, min, s) = if let Some(ts) = time_str {
        parse_time_str_with_ampm(ts)?
    } else {
        (0, 0, 0)
    };

    RosettaDateTime::from_components(year, month, day, h, min, s, *offset).ok()
}

/// Parse ["2021", "04", "30"] or ["2021", "Feb", "21"] etc.
fn parse_date_segments(segs: &[&str]) -> Option<(i32, u8, u8)> {
    debug_assert_eq!(segs.len(), 3);
    let a = segs[0];
    let b = segs[1];
    let c = segs[2];

    // Check if middle segment is a month name (yyyy-Mon-dd)
    if let Some(m) = month_from_name(b) {
        let y: i32 = expand_year(a).ok()?;
        let d: u8 = c.parse().ok()?;
        return Some((y, m, d));
    }
    if let Some(m) = month_from_name(a) {
        // Mon-dd-yyyy
        let d: u8 = b.parse().ok()?;
        let y: i32 = expand_year(c).ok()?;
        return Some((y, m, d));
    }

    let ai: i32 = a.parse().ok()?;
    let bi: i32 = b.parse().ok()?;
    let ci: i32 = c.parse().ok()?;

    // YMD if first component > 31
    if ai > 31 {
        return Some((ai, bi as u8, ci as u8));
    }
    // MDY if last component > 31 and first <= 12
    if ci > 31 && ai <= 12 {
        return Some((expand_year_i32(ci), ai as u8, bi as u8));
    }
    // DMY if last component > 31 and first > 12
    if ci > 31 && ai > 12 {
        return Some((expand_year_i32(ci), bi as u8, ai as u8));
    }
    // 2-digit year: assume MDY (common in US formats)
    if ci <= 99 && ai <= 12 {
        return Some((expand_year_i32(ci), ai as u8, bi as u8));
    }

    None
}

// ── Separator normalisation ───────────────────────────────────────────

fn normalise_separators(s: &str) -> String {
    // Replace "/" and "." with "-" ONLY in the date portion (before any space).
    // This avoids turning fractional-second dots into dashes.
    if let Some(sp) = s.find(' ') {
        let date_part: String = s[..sp]
            .chars()
            .map(|c| if c == '/' || c == '.' { '-' } else { c })
            .collect();
        format!("{}{}", date_part, &s[sp..])
    } else {
        s.chars()
            .map(|c| if c == '/' || c == '.' { '-' } else { c })
            .collect()
    }
}

// ── Time string parsers ───────────────────────────────────────────────

/// Parse "hh:mm:ss[.frac][am|pm]" → (h, m, s).  Fractional seconds truncated.
fn parse_time_str(ts: &str) -> Option<(u8, u8, u8)> {
    let lower = ts.to_lowercase();
    let (s_stripped, is_pm) = if lower.ends_with("pm") {
        (&ts[..ts.len() - 2].trim_end(), true)
    } else if lower.ends_with("am") {
        (&ts[..ts.len() - 2].trim_end(), false)
    } else {
        (&ts, false)
    };

    let mut segs = s_stripped.splitn(3, ':');
    let h_str = segs.next()?;
    let m_str = segs.next().unwrap_or("0");
    let s_str = segs.next().unwrap_or("0");

    let mut h: u8 = h_str.trim().parse().ok()?;
    let m: u8 = m_str.trim().parse().ok()?;
    // Strip fractional seconds
    let s_base = s_str.split('.').next().unwrap_or("0");
    let s: u8 = s_base.trim().parse().ok()?;

    if is_pm && h != 12 {
        h = h.saturating_add(12);
    } else if !is_pm && h == 12 {
        h = 0;
    }

    if h > 23 {
        return None;
    }
    Some((h, m, s))
}

fn parse_time_str_with_ampm(ts: &str) -> Option<(u8, u8, u8)> {
    // Handle combined token like "5:57:51PM" or separate "5:57:51 PM"
    // Both handled by parse_time_str.
    // If space-separated AM/PM: join back.
    let toks: Vec<&str> = ts.split_whitespace().collect();
    let unified = toks.join("");
    parse_time_str(&unified)
}

/// Parse a slice of string tokens to extract (hour, min, sec, has_ampm).
/// Tokens may be like ["5:57:51", "PM"] or ["10:09am"] or ["19:17"] etc.
fn parse_time_tokens(toks: &[&str]) -> (u8, u8, u8, bool) {
    if toks.is_empty() {
        return (0, 0, 0, false);
    }
    let joined = toks.join(" ");
    if let Some((h, m, s)) = parse_time_str(&joined) {
        let lower = joined.to_lowercase();
        let has = lower.contains("pm") || lower.contains("am");
        (h, m, s, has)
    } else {
        (0, 0, 0, false)
    }
}

// ── Month name helpers ────────────────────────────────────────────────

fn month_from_name(s: &str) -> Option<u8> {
    let s = s.trim_end_matches('.').to_lowercase();
    match s.as_str() {
        "jan" | "january" => Some(1),
        "feb" | "february" => Some(2),
        "mar" | "march" => Some(3),
        "apr" | "april" => Some(4),
        "may" => Some(5),
        "jun" | "june" => Some(6),
        "jul" | "july" => Some(7),
        "aug" | "august" => Some(8),
        "sep" | "sept" | "september" => Some(9),
        "oct" | "october" => Some(10),
        "nov" | "november" => Some(11),
        "dec" | "december" => Some(12),
        _ => None,
    }
}

// ── Year helpers ──────────────────────────────────────────────────────

fn expand_year(s: &str) -> std::result::Result<i32, ()> {
    let n: i32 = s.parse().map_err(|_| ())?;
    Ok(expand_year_i32(n))
}

fn expand_year_i32(n: i32) -> i32 {
    match n {
        0..=69 => 2000 + n,
        70..=99 => 1900 + n,
        _ => n,
    }
}

fn default_year() -> i32 {
    // Use current year as fallback for month-day-only inputs
    RosettaDateTime::now_utc().year()
}

fn strip_ordinal(s: &str) -> &str {
    s.trim_end_matches("st")
        .trim_end_matches("nd")
        .trim_end_matches("rd")
        .trim_end_matches("th")
}

// ── Postgres offset splitter ──────────────────────────────────────────
// Handles "2019-11-29 08:08-08" where the offset is glued to the time part
// without a separating space.

fn split_postgres_offset(input: &str) -> Option<(String, TzOffset)> {
    // We only activate this for strings that have a date portion (contain '-')
    // and whose time segment has a glued offset.
    // Strategy: find the second whitespace-delimited token (time token) and
    // look for a leading '+'/'-' that isn't part of a ':' time component.

    let parts: Vec<&str> = input.splitn(2, ' ').collect();
    if parts.len() != 2 {
        return None;
    }
    let date_part = parts[0];
    let time_and_offset = parts[1];

    // Must look like a date (contains '-')
    if !date_part.contains('-') {
        return None;
    }

    // Find +/- in time_and_offset that is NOT at the start of the whole
    // string and is preceded by a digit.
    // We scan for the first occurrence of '+' or '-' that follows a digit.
    let bytes = time_and_offset.as_bytes();
    let mut split_pos: Option<usize> = None;
    for i in 1..bytes.len() {
        let b = bytes[i];
        if (b == b'+' || b == b'-') && bytes[i - 1].is_ascii_digit() {
            split_pos = Some(i);
            break;
        }
    }

    let pos = split_pos?;
    let time_clean = &time_and_offset[..pos];
    let offset_str = &time_and_offset[pos..];

    let offset = crate::timezone::parse_timezone(offset_str).ok()?;
    Some((format!("{} {}", date_part, time_clean), offset))
}