rosetta_date/

nlp.rs

//! Natural language date parsing: tokenizer, relative & absolute time parsing.

use crate::datetime::RosettaDateTime;
use crate::error::{Result, RosettaError};
use crate::i18n::{self, Direction, LanguageData, SpecialWord, TimeUnit};

// ── Public API ────────────────────────────────────────────────────────

/// Attempt to parse a natural-language date/time expression.
///
/// `base` is the reference time (usually "now") against which relative
/// expressions like "2 hours ago" are resolved.
pub fn parse_nlp(
    input: &str,
    base: &RosettaDateTime,
    languages: Option<&[&LanguageData]>,
) -> Result<RosettaDateTime> {
    let input_clean = input.trim();
    let input_clean_lower = input_clean.to_lowercase();

    // Determine which languages to try
    let available = i18n::available_languages();
    let langs: Vec<&LanguageData> = match languages {
        Some(l) => l.to_vec(),
        None => {
            // Auto-detect or try all
            let detected = i18n::detect_language(&input_clean_lower);
            if !detected.is_empty() {
                detected
            } else {
                available.to_vec()
            }
        }
    };

    for lang in &langs {
        // Try special standalone words first (yesterday, today, tomorrow, etc.)
        if let Some(dt) = try_special_words(&input_clean_lower, base, lang) {
            return Ok(dt);
        }
        // Try relative time expressions (2 hours ago, 3天前, in 5 days)
        if let Some(dt) = try_relative_parse(&input_clean_lower, base, lang) {
            return Ok(dt);
        }
        // Try modifier + unit (last week, next month, 上周, 下个月)
        if let Some(dt) = try_modifier_unit(&input_clean_lower, base, lang) {
            return Ok(dt);
        }
        // Try absolute month/day parsing (January 1st 2023, 1月15日)
        if let Some(dt) = try_absolute_nlp(&input_clean_lower, base, lang) {
            return Ok(dt);
        }
    }

    Err(RosettaError::ParseError(format!(
        "Could not parse natural language date: '{}'",
        input
    )))
}

// ── Special Words ─────────────────────────────────────────────────────

fn try_special_words(
    input: &str,
    base: &RosettaDateTime,
    lang: &LanguageData,
) -> Option<RosettaDateTime> {
    let input = input.trim();

    for &(word_type, words) in lang.special_words {
        for &w in words {
            if input == w {
                let dt = match word_type {
                    SpecialWord::Now => base.clone(),
                    SpecialWord::Yesterday => base.clone().add_days(-1),
                    SpecialWord::Today => base.clone(),
                    SpecialWord::Tomorrow => base.clone().add_days(1),
                    SpecialWord::DayBeforeYesterday => base.clone().add_days(-2),
                    SpecialWord::DayAfterTomorrow => base.clone().add_days(2),
                };
                return Some(dt);
            }
        }
    }
    None
}

// ── Relative Time ─────────────────────────────────────────────────────

pub fn try_relative_parse(
    input: &str,
    base: &RosettaDateTime,
    lang: &LanguageData,
) -> Option<RosettaDateTime> {
    // Pattern 1: "<number> <unit> ago/前"  (e.g. "2 hours ago", "3天前")
    // Pattern 2: "in <number> <unit>"      (e.g. "in 5 days")
    // Pattern 3: "<number> <unit> later/后" (e.g. "5 days later", "3天后")

    // First check for direction keywords to know if past/future
    let mut direction: Option<Direction> = None;

    // Check for "ago" / "前" style suffixes → Past
    for &ago in lang.ago_words {
        if input.ends_with(&ago) || input.contains(ago) {
            direction = Some(Direction::Past);
            break;
        }
    }

    // Check for "from now" / "later" / "后" style suffixes → Future
    if direction.is_none() {
        for &fw in lang.future_words {
            if input.ends_with(&fw) || input.contains(fw) {
                direction = Some(Direction::Future);
                break;
            }
        }
    }

    // Check for "in" prefix → Future
    if direction.is_none() {
        for &prefix in lang.future_prefix {
            let p = prefix;
            if input.starts_with(p) && input.len() > p.len() {
                let next_char = input[p.len()..].chars().next();
                if next_char == Some(' ') || next_char.is_some_and(|c| !c.is_ascii_alphabetic()) {
                    direction = Some(Direction::Future);
                    break;
                }
            }
        }
    }

    // Check for "hace"/"il y a"/"vor" prefix → Past
    if direction.is_none() {
        for &prefix in lang.past_prefix {
            let p = prefix;
            if input.starts_with(p) && input.len() > p.len() {
                let next_char = input[p.len()..].chars().next();
                if next_char == Some(' ') || next_char.is_some_and(|c| !c.is_ascii_alphabetic()) {
                    direction = Some(Direction::Past);
                    break;
                }
            }
        }
    }

    let direction = direction?;

    // Now find a number and a time unit in the string
    let (number, unit) = extract_number_and_unit(input, lang)?;

    let seconds = unit_to_seconds(unit, number);
    let multiplier = match direction {
        Direction::Past => -1i64,
        Direction::Future => 1i64,
    };

    Some(base.clone().add_seconds(seconds * multiplier))
}

// ── Modifier + Unit ───────────────────────────────────────────────────

pub fn try_modifier_unit(
    input: &str,
    base: &RosettaDateTime,
    lang: &LanguageData,
) -> Option<RosettaDateTime> {
    // "last week" / "上周" → base - 1 week
    // "next month" / "下个月" → base + 1 month
    // "this year" / "今年" → base (no change)

    let mut modifier: Option<i64> = None;

    for &w in lang.last_words {
        if input.contains(w) {
            modifier = Some(-1);
            break;
        }
    }
    if modifier.is_none() {
        for &w in lang.next_words {
            if input.contains(w) {
                modifier = Some(1);
                break;
            }
        }
    }
    if modifier.is_none() {
        for &w in lang.this_words {
            if input.contains(w) {
                modifier = Some(0);
                break;
            }
        }
    }

    let modifier = modifier?;

    // Find the unit
    for &(unit, keywords) in lang.time_units {
        for &kw in keywords {
            if input.contains(kw) {
                let secs = unit_to_seconds(unit, modifier.unsigned_abs() as i64);
                return Some(base.clone().add_seconds(secs * modifier.signum()));
            }
        }
    }

    None
}

// ── Absolute NLP ──────────────────────────────────────────────────────

pub fn try_absolute_nlp(
    input: &str,
    base: &RosettaDateTime,
    lang: &LanguageData,
) -> Option<RosettaDateTime> {
    // Try to find a month name in the string
    let mut found_month: Option<u8> = None;
    let mut month_pos: usize = 0;
    let mut month_len: usize = 0;

    // Check long month names first (more specific)
    for (i, &name) in lang.months_long.iter().enumerate() {
        let name_lower = name;
        if let Some(pos) = find_word(input, name_lower)
            && !is_direction_word(name_lower, lang)
        {
            found_month = Some((i + 1) as u8);
            month_pos = pos;
            month_len = name.len();
            break;
        }
    }

    // Fall back to short month names
    if found_month.is_none() {
        for (i, &name) in lang.months_short.iter().enumerate() {
            let name_lower = name;
            if !name_lower.is_empty()
                && let Some(pos) = find_word(input, name_lower)
                && !is_direction_word(name_lower, lang)
            {
                found_month = Some((i + 1) as u8);
                month_pos = pos;
                month_len = name.len();
                break;
            }
        }
    }

    let month = found_month?;

    // Extract time pattern (HH:MM or HH:MM:SS) from the full string
    let (time_hour, time_minute, time_second, time_range) = extract_time_pattern(input, lang);

    // Extract numbers from the string, excluding the time pattern range
    let before_month = &input[..month_pos];
    let after_month = &input[month_pos + month_len..];

    let numbers_before = extract_all_numbers(before_month);
    let numbers_after =
        extract_all_numbers_excluding(after_month, &time_range, month_pos + month_len);

    let all_numbers: Vec<i64> = numbers_before
        .iter()
        .chain(numbers_after.iter())
        .copied()
        .collect();

    // Determine day and year from context
    let (day, year) = match all_numbers.len() {
        0 => (1u8, base.year()),
        1 => {
            let n = all_numbers[0];
            if n > 31 {
                (1u8, n as i32) // it's a year
            } else {
                (n as u8, base.year()) // it's a day
            }
        }
        _ => {
            // Two or more numbers: figure out which is day and which is year
            let (mut day, mut year) = (1u8, base.year());
            for &n in &all_numbers {
                if n > 31 {
                    year = n as i32;
                } else if day == 1 {
                    day = n as u8;
                }
            }
            (day, year)
        }
    };

    let hour = time_hour.unwrap_or(0);
    let minute = time_minute.unwrap_or(0);
    let second = time_second.unwrap_or(0);

    RosettaDateTime::from_components(year, month, day, hour, minute, second, base.offset()).ok()
}

/// Extract a time pattern (HH:MM or HH:MM:SS) from a string.
/// Also handles AM/PM. Returns (hour, minute, second, byte_range_in_original).
fn extract_time_pattern(
    input: &str,
    lang: &LanguageData,
) -> (
    Option<u8>,
    Option<u8>,
    Option<u8>,
    Option<std::ops::Range<usize>>,
) {
    // Scan for digit:digit pattern
    let bytes = input.as_bytes();
    let len = bytes.len();
    let mut i = 0;

    while i < len {
        // Find a ':' that has digits on both sides
        if bytes[i] == b':' && i > 0 && i + 1 < len {
            // Find hour digits before ':'
            let mut h_start = i;
            while h_start > 0 && bytes[h_start - 1].is_ascii_digit() {
                h_start -= 1;
            }
            if h_start == i {
                i += 1;
                continue;
            }

            // Find minute digits after ':'
            let mut m_end = i + 1;
            while m_end < len && bytes[m_end].is_ascii_digit() {
                m_end += 1;
            }
            if m_end == i + 1 {
                i += 1;
                continue;
            }

            let h_str = &input[h_start..i];
            let m_str = &input[i + 1..m_end];

            if let (Ok(h), Ok(m)) = (h_str.parse::<u8>(), m_str.parse::<u8>())
                && h <= 23
                && m <= 59
            {
                // Check for seconds
                let (s, range_end) = if m_end < len && bytes[m_end] == b':' {
                    let mut s_end = m_end + 1;
                    while s_end < len && bytes[s_end].is_ascii_digit() {
                        s_end += 1;
                    }
                    let s_str = &input[m_end + 1..s_end];
                    if let Ok(s) = s_str.parse::<u8>() {
                        (Some(s), s_end)
                    } else {
                        (None, m_end)
                    }
                } else {
                    (None, m_end)
                };

                // Check for AM/PM after the time
                let after_time = &input[range_end..].trim_start();
                let mut hour = h;

                for &pm in lang.pm_indicators {
                    if after_time.starts_with(pm) {
                        if hour < 12 {
                            hour += 12;
                        }
                        break;
                    }
                }
                for &am in lang.am_indicators {
                    if after_time.starts_with(am) {
                        if hour == 12 {
                            hour = 0;
                        }
                        break;
                    }
                }

                return (Some(hour), Some(m), s, Some(h_start..range_end));
            }
        }
        i += 1;
    }

    (None, None, None, None)
}

/// Extract all numbers from a string, excluding those within a given byte range.
fn extract_all_numbers_excluding(
    s: &str,
    exclude_range: &Option<std::ops::Range<usize>>,
    offset: usize, // byte offset of `s` within the original string
) -> Vec<i64> {
    let mut result = Vec::new();
    let mut current = String::new();
    let mut byte_pos = 0;

    for c in s.chars() {
        let char_len = c.len_utf8();
        let abs_pos = offset + byte_pos;

        if c.is_ascii_digit() {
            // Check if this position falls within the excluded range
            let excluded = exclude_range
                .as_ref()
                .is_some_and(|r| abs_pos >= r.start && abs_pos < r.end);
            if excluded {
                if !current.is_empty() {
                    if let Ok(n) = current.parse::<i64>() {
                        result.push(n);
                    }
                    current.clear();
                }
            } else {
                current.push(c);
            }
        } else {
            if !current.is_empty() {
                if let Ok(n) = current.parse::<i64>() {
                    result.push(n);
                }
                current.clear();
            }
        }
        byte_pos += char_len;
    }
    if !current.is_empty()
        && let Ok(n) = current.parse::<i64>()
    {
        result.push(n);
    }
    result
}

// ── Helpers ───────────────────────────────────────────────────────────

/// Extract a number and a time unit from the input string.
fn extract_number_and_unit(input: &str, lang: &LanguageData) -> Option<(i64, TimeUnit)> {
    // Try to find a time unit keyword
    for &(unit, keywords) in lang.time_units {
        // Sort keywords by length desc so we match longest first
        let mut kw_sorted: Vec<&str> = keywords.to_vec();
        kw_sorted.sort_by_key(|b| std::cmp::Reverse(b.len()));

        for kw in kw_sorted {
            let kw_lower = kw;
            if let Some(pos) = input.find(kw_lower) {
                // Look for a number before the unit
                let before = &input[..pos];
                if let Some(n) = extract_number_from_end(before.trim_end(), lang) {
                    return Some((n, unit));
                }
                // Look for a number after the unit
                let after = &input[pos + kw.len()..];
                if let Some(n) = extract_number_from_start(after.trim_start(), lang) {
                    return Some((n, unit));
                }
            }
        }
    }
    None
}

/// Extract a number from the end of a string.
fn extract_number_from_end(s: &str, lang: &LanguageData) -> Option<i64> {
    if s.is_empty() {
        return None;
    }

    // Try Arabic digits at the end
    let digit_str: String = s
        .chars()
        .rev()
        .take_while(|c| c.is_ascii_digit())
        .collect::<String>()
        .chars()
        .rev()
        .collect();
    if !digit_str.is_empty() {
        return digit_str.parse().ok();
    }

    // Try number words (check from longest match)
    try_number_word(s, lang)
}

/// Extract a number from the start of a string.
fn extract_number_from_start(s: &str, lang: &LanguageData) -> Option<i64> {
    if s.is_empty() {
        return None;
    }

    // Try Arabic digits at the start
    let digit_str: String = s.chars().take_while(|c| c.is_ascii_digit()).collect();
    if !digit_str.is_empty() {
        return digit_str.parse().ok();
    }

    // Try number words
    try_number_word(s, lang)
}

/// Try matching number words from the language data.
fn try_number_word(s: &str, lang: &LanguageData) -> Option<i64> {
    let trimmed = s.trim();

    // Sort by length desc for longest-match-first
    let mut words: Vec<(&str, i64)> = lang.number_words.to_vec();
    words.sort_by_key(|a| std::cmp::Reverse(a.0.len()));

    for (word, val) in words {
        let w = word;
        if trimmed == w {
            return Some(val);
        }
        if let Some(stripped) = trimmed.strip_prefix(w) {
            if let Some(next_char) = stripped.chars().next() {
                if !next_char.is_ascii_alphabetic() {
                    return Some(val);
                }
            } else {
                return Some(val);
            }
        }
        if trimmed.ends_with(&w) {
            let prev_str = &trimmed[..trimmed.len() - w.len()];
            if let Some(prev_char) = prev_str.chars().last() {
                if !prev_char.is_ascii_alphabetic() {
                    return Some(val);
                }
            } else {
                return Some(val);
            }
        }
    }

    // Handle Chinese composite numbers like "十二" (12), "二十" (20), "二十三" (23)
    if let Some(n) = try_chinese_number(trimmed, lang) {
        return Some(n);
    }

    None
}

/// Parse simple Chinese composite numbers (e.g. 十二=12, 二十三=23).
fn try_chinese_number(s: &str, lang: &LanguageData) -> Option<i64> {
    let chars: Vec<char> = s.chars().collect();
    if chars.is_empty() {
        return None;
    }

    // Build a lookup from character to value
    let lookup = |c: char| -> Option<i64> {
        for &(word, val) in lang.number_words {
            let wc: Vec<char> = word.chars().collect();
            if wc.len() == 1 && wc[0] == c {
                return Some(val);
            }
        }
        None
    };

    if chars.len() == 1 {
        return lookup(chars[0]);
    }

    // Two-char patterns:
    // "十X" = 10 + X,  "X十" = X * 10
    if chars.len() == 2 {
        let a = lookup(chars[0]);
        let b = lookup(chars[1]);
        match (a, b) {
            (Some(10), Some(bv)) if bv < 10 => return Some(10 + bv), // 十二 = 12
            (Some(av), Some(10)) if av < 10 => return Some(av * 10), // 二十 = 20
            _ => {}
        }
    }

    // Three-char: "X十Y" = X * 10 + Y
    if chars.len() == 3 {
        let a = lookup(chars[0]);
        let b = lookup(chars[1]);
        let c = lookup(chars[2]);
        if let (Some(av), Some(10), Some(cv)) = (a, b, c)
            && av < 10
            && cv < 10
        {
            return Some(av * 10 + cv); // 二十三 = 23
        }
    }

    None
}

/// Extract all plain integer numbers from a string.
fn extract_all_numbers(s: &str) -> Vec<i64> {
    let mut result = Vec::new();
    let mut current = String::new();

    for c in s.chars() {
        if c.is_ascii_digit() {
            current.push(c);
        } else {
            if !current.is_empty() {
                if let Ok(n) = current.parse::<i64>() {
                    result.push(n);
                }
                current.clear();
            }
        }
    }
    if !current.is_empty()
        && let Ok(n) = current.parse::<i64>()
    {
        result.push(n);
    }
    result
}

/// Convert a time unit + count to total seconds.
fn unit_to_seconds(unit: TimeUnit, count: i64) -> i64 {
    let count = if count == -1 { 1 } else { count }; // -1 is "half", approximate as 1
    match unit {
        TimeUnit::Second => count,
        TimeUnit::Minute => count * 60,
        TimeUnit::Hour => count * 3600,
        TimeUnit::Day => count * 86400,
        TimeUnit::Week => count * 7 * 86400,
        TimeUnit::Month => count * 30 * 86400,
        TimeUnit::Year => count * 365 * 86400,
    }
}

/// Returns true if `word` is also used as a past/future direction indicator
/// in this language (e.g. Portuguese "ago" = August AND past indicator).
/// Such words must not be treated as month names in absolute NLP parsing.
fn is_direction_word(word: &str, lang: &LanguageData) -> bool {
    let w = word;
    for &ago in lang.ago_words {
        if w == ago {
            return true;
        }
    }
    for &fw in lang.future_words {
        if w == fw {
            return true;
        }
    }
    for &pp in lang.past_prefix {
        if w == pp {
            return true;
        }
    }
    for &fp in lang.future_prefix {
        if w == fp {
            return true;
        }
    }
    false
}

/// Find `needle` in `haystack` only at word boundaries (surrounded by
/// non-alphabetic chars or at start/end of string).  Returns the byte
/// position of the first match, or `None`.
fn find_word(haystack: &str, needle: &str) -> Option<usize> {
    if needle.is_empty() {
        return None;
    }
    let bytes = haystack.as_bytes();
    let nbytes = needle.as_bytes();
    let nlen = nbytes.len();

    let mut i = 0;
    while i + nlen <= bytes.len() {
        if &bytes[i..i + nlen] == nbytes {
            let before_ok = if i == 0 {
                true
            } else {
                !bytes[i - 1].is_ascii_alphabetic()
            };
            let after_ok = if i + nlen >= bytes.len() {
                true
            } else {
                !bytes[i + nlen].is_ascii_alphabetic()
            };
            if before_ok && after_ok {
                return Some(i);
            }
        }
        i += 1;
    }
    None
}

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

    fn base_time() -> RosettaDateTime {
        // 2023-10-15 12:00:00 UTC
        RosettaDateTime::from_components(2023, 10, 15, 12, 0, 0, crate::timezone::TzOffset::UTC)
            .unwrap()
    }

    #[cfg(feature = "lang-en")]
    #[test]
    fn test_english_yesterday() {
        let base = base_time();
        let result = parse_nlp("yesterday", &base, None).unwrap();
        assert_eq!(result.day(), 14);
        assert_eq!(result.month(), 10);
    }

    #[cfg(feature = "lang-en")]
    #[test]
    fn test_english_tomorrow() {
        let base = base_time();
        let result = parse_nlp("tomorrow", &base, None).unwrap();
        assert_eq!(result.day(), 16);
    }

    #[cfg(feature = "lang-en")]
    #[test]
    fn test_english_hours_ago() {
        let base = base_time();
        let result = parse_nlp("2 hours ago", &base, None).unwrap();
        assert_eq!(result.hour(), 10);
    }

    #[cfg(feature = "lang-en")]
    #[test]
    fn test_english_in_5_days() {
        let base = base_time();
        let result = parse_nlp("in 5 days", &base, None).unwrap();
        assert_eq!(result.day(), 20);
    }

    #[cfg(feature = "lang-en")]
    #[test]
    fn test_english_3_weeks_ago() {
        let base = base_time();
        let result = parse_nlp("3 weeks ago", &base, None).unwrap();
        // 15 - 21 = Sept 24
        assert_eq!(result.month(), 9);
        assert_eq!(result.day(), 24);
    }

    #[cfg(feature = "lang-en")]
    #[test]
    fn test_english_month_day() {
        let base = base_time();
        let result = parse_nlp("January 15", &base, None).unwrap();
        assert_eq!(result.month(), 1);
        assert_eq!(result.day(), 15);
    }

    #[cfg(feature = "lang-en")]
    #[test]
    fn test_english_month_day_year() {
        let base = base_time();
        let result = parse_nlp("March 5 2025", &base, None).unwrap();
        assert_eq!(result.month(), 3);
        assert_eq!(result.day(), 5);
        assert_eq!(result.year(), 2025);
    }

    #[cfg(feature = "lang-zh")]
    #[test]
    fn test_chinese_yesterday() {
        let base = base_time();
        let result = parse_nlp("昨天", &base, None).unwrap();
        assert_eq!(result.day(), 14);
    }

    #[cfg(feature = "lang-zh")]
    #[test]
    fn test_chinese_3_hours_ago() {
        let base = base_time();
        let result = parse_nlp("3小时前", &base, None).unwrap();
        assert_eq!(result.hour(), 9);
    }

    #[cfg(feature = "lang-zh")]
    #[test]
    fn test_chinese_day_before_yesterday() {
        let base = base_time();
        let result = parse_nlp("前天", &base, None).unwrap();
        assert_eq!(result.day(), 13);
    }
}