use chrono::NaiveDate;
use regex::Regex;
use serde_json::json;
use std::sync::OnceLock;
fn iso_regex() -> &'static Regex {
static RE: OnceLock<Regex> = OnceLock::new();
RE.get_or_init(|| Regex::new(r"\b(\d{4}-\d{2}-\d{2})\b").unwrap())
}
fn dmy_regex() -> &'static Regex {
static RE: OnceLock<Regex> = OnceLock::new();
RE.get_or_init(|| {
Regex::new(
r"\b(\d{1,2}\s+(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{4})\b",
)
.unwrap()
})
}
fn symbol_regex() -> &'static Regex {
static RE: OnceLock<Regex> = OnceLock::new();
RE.get_or_init(|| {
Regex::new(r"([$€£₹¥])\s*(\d{1,3}(?:[,\s]\d{3})*(?:[.,]\d+)?|\d+(?:[.,]\d+)?)").unwrap()
})
}
fn code_regex() -> &'static Regex {
static RE: OnceLock<Regex> = OnceLock::new();
RE.get_or_init(|| {
Regex::new(
r"(\d{1,3}(?:[,\s]\d{3})*(?:[.,]\d+)?|\d+(?:[.,]\d+)?)\s+(USD|EUR|GBP|INR|JPY)\b",
)
.unwrap()
})
}
pub fn extract_dates(text: &str) -> Vec<String> {
let mut dates = Vec::new();
for cap in iso_regex().captures_iter(text) {
let s = &cap[1];
if NaiveDate::parse_from_str(s, "%Y-%m-%d").is_ok() {
dates.push(s.to_string());
}
}
for cap in dmy_regex().captures_iter(text) {
let s = &cap[1];
if NaiveDate::parse_from_str(s, "%d %b %Y").is_ok()
|| NaiveDate::parse_from_str(s, "%d %B %Y").is_ok()
{
dates.push(s.to_string());
}
}
let mut seen = std::collections::HashSet::new();
dates.retain(|d| seen.insert(d.clone()));
dates
}
pub fn extract_amounts(text: &str) -> Vec<(f64, String)> {
let mut amounts = Vec::new();
for cap in symbol_regex().captures_iter(text) {
let symbol = &cap[1];
let amount_str = &cap[2];
if let Some((amount, code)) = parse_amount_with_symbol(amount_str, symbol) {
amounts.push((amount, code));
}
}
for cap in code_regex().captures_iter(text) {
let amount_str = &cap[1];
let code = &cap[2];
if let Some(amount) = parse_number(amount_str) {
amounts.push((amount, code.to_string()));
}
}
let mut seen = std::collections::HashSet::new();
amounts.retain(|a| {
let key = (ordered_float::OrderedFloat(a.0), a.1.clone());
seen.insert(key)
});
amounts
}
fn parse_amount_with_symbol(amount_str: &str, symbol: &str) -> Option<(f64, String)> {
let code = match symbol {
"$" => "USD",
"€" => "EUR",
"£" => "GBP",
"₹" => "INR",
"¥" => "JPY",
_ => return None,
};
parse_number(amount_str).map(|n| (n, code.to_string()))
}
fn parse_number(s: &str) -> Option<f64> {
let s = s.replace(' ', "");
if s.contains(',') && s.contains('.') {
let last_comma = s.rfind(',').unwrap();
let last_dot = s.rfind('.').unwrap();
if last_comma > last_dot {
let s = s.replace('.', "").replace(',', ".");
s.parse().ok()
} else {
s.replace(',', "").parse().ok()
}
} else if s.contains(',') {
let parts: Vec<&str> = s.split(',').collect();
if parts.len() == 2 && parts[1].len() == 2 {
format!("{}.{}", parts[0], parts[1]).parse().ok()
} else {
s.replace(',', "").parse().ok()
}
} else if s.contains('.') {
let parts: Vec<&str> = s.split('.').collect();
if parts.len() == 2 && parts[1].len() == 3 {
s.replace('.', "").parse().ok()
} else {
s.parse().ok()
}
} else {
s.parse().ok()
}
}
pub fn extract_kind(text: &str) -> Option<&'static str> {
let lower = text.to_lowercase();
if lower.contains("warranty") {
return Some("warranty");
}
if lower.contains("receipt") {
return Some("receipt");
}
if lower.contains("invoice") {
return Some("invoice");
}
if lower.contains("contract") {
return Some("contract");
}
None
}
pub fn analyse(text: &str) -> String {
let dates = extract_dates(text);
let amounts = extract_amounts(text);
let kind = extract_kind(text);
let amounts_json: Vec<serde_json::Value> = amounts
.into_iter()
.map(|(amt, code)| json!({"amount": amt, "currency": code}))
.collect();
let result = json!({
"dates": dates,
"amounts": amounts_json,
"kind": kind.unwrap_or(""),
});
result.to_string()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_extract_iso_dates() {
let text = "The warranty expires on 2027-01-15 and starts 2024-06-01.";
let dates = extract_dates(text);
assert_eq!(dates, vec!["2027-01-15", "2024-06-01"]);
}
#[test]
fn test_extract_dmy_dates() {
let text = "Signed on 15 Jan 2027 and delivered 1 January 2024.";
let dates = extract_dates(text);
assert_eq!(dates, vec!["15 Jan 2027", "1 January 2024"]);
}
#[test]
fn test_extract_dates_deduplicates() {
let text = "2027-01-15 and again 2027-01-15";
let dates = extract_dates(text);
assert_eq!(dates, vec!["2027-01-15"]);
}
#[test]
fn test_extract_amounts_symbols() {
let text = "Total: $1,234.56 and €99.99 and £100 and ₹5000 and ¥10000";
let amounts = extract_amounts(text);
eprintln!("Extracted amounts: {:?}", amounts);
assert!(amounts.iter().any(|(a, c)| *a == 1234.56 && c == "USD"));
assert!(amounts.iter().any(|(a, c)| *a == 99.99 && c == "EUR"));
assert!(amounts.iter().any(|(a, c)| *a == 100.0 && c == "GBP"));
}
#[test]
fn test_extract_amounts_codes() {
let text = "Amount: 1234.56 USD and 99,99 EUR and 100 GBP";
let amounts = extract_amounts(text);
assert_eq!(amounts.len(), 3);
assert!(amounts.iter().any(|(a, c)| *a == 1234.56 && c == "USD"));
assert!(amounts.iter().any(|(a, c)| *a == 99.99 && c == "EUR"));
assert!(amounts.iter().any(|(a, c)| *a == 100.0 && c == "GBP"));
}
#[test]
fn test_extract_amounts_european_format() {
let text = "Price: 1.234,56 EUR";
let amounts = extract_amounts(text);
eprintln!("European format amounts: {:?}", amounts);
assert!(amounts.iter().any(|(_a, c)| c == "EUR"));
}
#[test]
fn test_extract_kind_warranty() {
let text = "This warranty covers parts for 24 months.";
assert_eq!(extract_kind(text), Some("warranty"));
}
#[test]
fn test_extract_kind_receipt() {
let text = "Receipt for payment of $100.";
assert_eq!(extract_kind(text), Some("receipt"));
}
#[test]
fn test_extract_kind_invoice() {
let text = "Invoice #1234 for services rendered.";
assert_eq!(extract_kind(text), Some("invoice"));
}
#[test]
fn test_extract_kind_contract() {
let text = "This contract is binding.";
assert_eq!(extract_kind(text), Some("contract"));
}
#[test]
fn test_extract_kind_priority() {
let text = "warranty receipt";
assert_eq!(extract_kind(text), Some("warranty"));
}
#[test]
fn test_extract_kind_none() {
let text = "Just some random text.";
assert_eq!(extract_kind(text), None);
}
#[test]
fn test_analyse_full() {
let text = "Warranty expires 2027-01-15. Total: $1,234.56";
let result = analyse(text);
let json: serde_json::Value = serde_json::from_str(&result).unwrap();
let dates: Vec<String> = json["dates"]
.as_array()
.unwrap()
.iter()
.map(|v| v.as_str().unwrap().to_string())
.collect();
assert_eq!(dates, vec!["2027-01-15"]);
let amounts = json["amounts"].as_array().unwrap();
assert!((amounts[0]["amount"].as_f64().unwrap() - 1234.56).abs() < 0.01);
assert_eq!(amounts[0]["currency"].as_str().unwrap(), "USD");
assert_eq!(json["kind"].as_str().unwrap(), "warranty");
}
#[test]
fn test_analyse_empty() {
let text = "No structured data here.";
let result = analyse(text);
let json: serde_json::Value = serde_json::from_str(&result).unwrap();
assert!(json["dates"]
.as_array()
.map(|a| a.is_empty())
.unwrap_or(true));
assert!(json["amounts"]
.as_array()
.map(|a| a.is_empty())
.unwrap_or(true));
assert!(json["kind"].as_str().unwrap_or("").is_empty());
}
}