1use crate::error::{HypermailError, Result};
2use crate::i18n::I18n;
3use chrono::{DateTime, FixedOffset, NaiveDateTime, Offset, TimeZone, Utc};
4use std::sync::LazyLock;
5
6pub const MONTHS: &[&str] = &[
7 "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
8];
9
10pub const DAYS: &[&str] = &["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
11
12pub fn localize_date_str(date_str: &str, lang: &str) -> String {
15 if lang == "en" {
16 return date_str.to_string();
17 }
18 let i18n = I18n::new(lang);
19 let mut result = date_str.to_string();
20
21 for &en_day in DAYS {
23 let localized = i18n.get(en_day);
24 if localized != en_day && result.contains(en_day) {
25 result = result.replacen(en_day, localized, 1);
26 break;
27 }
28 }
29
30 for &en_month in MONTHS {
32 let localized = i18n.get(en_month);
33 if localized != en_month && result.contains(en_month) {
34 result = result.replacen(en_month, localized, 1);
35 break;
36 }
37 }
38
39 result
40}
41
42pub fn is_leap(y: i32) -> bool {
43 y > 1752 && (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))
44}
45
46pub fn month_from_str(s: &str) -> Option<u32> {
47 MONTHS.iter().position(|&m| m.eq_ignore_ascii_case(s)).map(|p| (p + 1) as u32)
48}
49
50pub fn parse_rfc2822_date(s: &str) -> Result<i64> {
51 let s = s.trim();
52
53 let parsed = DateTime::parse_from_rfc2822(s);
54 if let Ok(dt) = parsed {
55 return Ok(dt.timestamp());
56 }
57
58 try_parse_flexible(s)
59}
60
61fn try_parse_flexible(s: &str) -> Result<i64> {
62 let s = s.trim().to_string();
63
64 if let Ok(dt) = DateTime::parse_from_rfc3339(&s) {
65 return Ok(dt.timestamp());
66 }
67
68 let cleaned = s.replace(" (", "(").replace(") ", ")").trim().to_string();
69
70 if let Ok(dt) = DateTime::parse_from_rfc2822(&cleaned) {
71 return Ok(dt.timestamp());
72 }
73
74 let normalized = normalize_nonstandard_tz(&cleaned);
77 if normalized != cleaned {
78 if let Ok(dt) = DateTime::parse_from_rfc2822(&normalized) {
79 return Ok(dt.timestamp());
80 }
81 }
82
83 if let Ok(naive) = NaiveDateTime::parse_from_str(&cleaned, "%a %b %d %H:%M:%S %Y") {
84 if let Some(local) = LocalFixOffset::local_to_fixed(naive) {
85 return Ok(local.timestamp());
86 }
87 }
88
89 if let Ok(naive) = chrono::NaiveDate::parse_from_str(&cleaned, "%Y-%m-%d")
90 .map(|d| d.and_hms_opt(0, 0, 0).unwrap())
91 {
92 if let Some(local) = LocalFixOffset::local_to_fixed(naive) {
93 return Ok(local.timestamp());
94 }
95 }
96
97 Err(HypermailError::DateParse(format!("Cannot parse date: {}", s)))
98}
99
100fn normalize_nonstandard_tz(s: &str) -> String {
103 let re = LazyLock::force(&NONSTANDARD_TZ_RE);
105 if let Some(cap) = re.captures(s) {
106 let sign = &cap[1];
107 let hours_str = &cap[2];
108 let mins_str = cap.get(3).map(|m| m.as_str()).unwrap_or("00");
109 let hours: i32 = hours_str.parse().unwrap_or(0);
110 let mins: i32 = mins_str.parse().unwrap_or(0);
111 let offset = format!("{}{:02}{:02}", sign, hours, mins);
112 let match_start = cap.get(0).unwrap().start();
114 let base = &s[..match_start];
116 return format!("{}{}", base.trim_end(), offset.replace("+", " +").replace("-", " -"));
117 }
118 s.to_string()
119}
120
121static NONSTANDARD_TZ_RE: std::sync::LazyLock<regex::Regex> = std::sync::LazyLock::new(|| {
122 regex::Regex::new(r"(?i)(?:GMT|UTC)([+-])(\d{1,2})(?::(\d{2}))?$").unwrap()
123});
124
125struct LocalFixOffset;
126
127impl LocalFixOffset {
128 fn local_to_fixed(naive: NaiveDateTime) -> Option<DateTime<FixedOffset>> {
129 let local_offset = chrono::Local::now().offset().fix();
130 match FixedOffset::east_opt(local_offset.local_minus_utc()) {
131 Some(fixed) => fixed.from_local_datetime(&naive).single(),
132 None => None,
133 }
134 }
135}
136
137fn clamp_timestamp(timestamp: i64) -> i64 {
141 const MIN_TS: i64 = -62167219200; const MAX_TS: i64 = 253402300799; timestamp.clamp(MIN_TS, MAX_TS)
144}
145
146pub fn get_date_str(
147 timestamp: i64,
148 fmt: Option<&str>,
149 gmtime: bool,
150 eurodate: bool,
151 isodate: bool,
152 lang: &str,
153) -> String {
154 let timestamp = clamp_timestamp(timestamp);
155 let dt: DateTime<FixedOffset> = if gmtime {
156 FixedOffset::east_opt(0).unwrap().from_utc_datetime(
157 &Utc.timestamp_opt(timestamp, 0).single().unwrap_or_default().naive_utc(),
158 )
159 } else {
160 match chrono::Local.timestamp_opt(timestamp, 0).single() {
161 Some(local) => {
162 let offset = *local.offset();
163 let naive = local.naive_local();
164 FixedOffset::east_opt(offset.local_minus_utc())
165 .unwrap()
166 .from_local_datetime(&naive)
167 .single()
168 .unwrap_or_else(|| {
169 FixedOffset::east_opt(0)
170 .unwrap()
171 .from_utc_datetime(&naive.and_utc().naive_utc())
172 })
173 },
174 None => {
175 FixedOffset::east_opt(0).unwrap().from_utc_datetime(
177 &Utc.timestamp_opt(timestamp, 0).single().unwrap_or_default().naive_utc(),
178 )
179 },
180 }
181 };
182
183 let raw = if let Some(format_str) = fmt {
184 let mut s = String::new();
186 if std::fmt::Write::write_fmt(&mut s, format_args!("{}", dt.format(format_str))).is_err() {
187 s = dt.to_rfc2822();
188 }
189 s
190 } else if isodate {
191 if gmtime {
192 dt.format("%Y-%m-%d %H:%M:%SZ").to_string()
193 } else {
194 dt.format("%Y-%m-%d %H:%M:%S").to_string()
195 }
196 } else if eurodate {
197 dt.format("%a %d %b %Y %H:%M:%S %z").to_string()
198 } else {
199 dt.format("%a %b %d %Y %H:%M:%S %z").to_string()
200 };
201
202 localize_date_str(&raw, lang)
203}
204
205pub fn secs_to_iso(timestamp: i64) -> String {
206 let timestamp = clamp_timestamp(timestamp);
207 let dt = Utc.timestamp_opt(timestamp, 0).single().unwrap_or_default();
208 dt.format("%Y-%m-%dT%H:%M:%SZ").to_string()
209}
210
211pub fn iso_to_secs(s: &str) -> Result<i64> {
212 let cleaned = s.trim();
213 if let Ok(dt) = DateTime::parse_from_rfc3339(cleaned) {
214 return Ok(dt.timestamp());
215 }
216 if let Ok(dt) = NaiveDateTime::parse_from_str(cleaned, "%Y-%m-%dT%H:%M:%S") {
217 return Ok(dt.and_utc().timestamp());
218 }
219 Err(HypermailError::DateParse(format!("Cannot parse ISO date: {}", s)))
220}
221
222pub fn get_timezone_str() -> String {
223 let offset = chrono::Local::now().offset().fix();
224 let total_secs = offset.local_minus_utc();
225 let hours = total_secs / 3600;
226 let mins = (total_secs.abs() / 60) % 60;
227 if total_secs >= 0 {
228 format!("+{:02}{:02}", hours, mins)
229 } else {
230 format!("-{:02}{:02}", -hours, mins)
231 }
232}
233
234#[cfg(test)]
235mod tests {
236 use super::*;
237 use chrono::Timelike;
238
239 #[test]
240 fn test_invalid_format_no_panic() {
241 let ds = get_date_str(1615809600, Some("%Q"), true, false, false, "en");
242 assert!(ds.contains("2021"), "fallback should still show the date: {ds}");
243 }
244
245 #[test]
246 fn test_parse_rfc2822() {
247 let ts = parse_rfc2822_date("Mon, 15 Mar 2021 12:00:00 +0000").unwrap();
248 assert_eq!(ts, 1615809600);
249
250 let ts = parse_rfc2822_date("15 Mar 2021 12:00:00 +0000").unwrap();
251 assert_eq!(ts, 1615809600);
252
253 let ts = parse_rfc2822_date("Mon, 15 Mar 2021 12:00:00 GMT").unwrap();
254 assert_eq!(ts, 1615809600);
255 }
256
257 #[test]
258 fn test_parse_various_dates() {
259 assert!(parse_rfc2822_date("Thu, 01 Jan 1998 00:00:00 +0000").is_ok());
260 assert!(parse_rfc2822_date("1 Jan 1998 00:00:00 +0000").is_ok());
261 assert!(parse_rfc2822_date("1 Jan 1998 00:00:00 +0100 (CET)").is_ok());
262 assert!(parse_rfc2822_date("Tue, 1 Jul 2003 10:52:37 +1200").is_ok());
263 }
264
265 #[test]
266 fn test_date_roundtrip() {
267 let original = "Mon, 15 Mar 2021 12:00:00 +0000";
268 let ts = parse_rfc2822_date(original).unwrap();
269 let formatted = secs_to_iso(ts);
270 assert!(formatted.starts_with("2021-03-15T12:00:00"));
271 }
272
273 #[test]
274 fn test_date_str() {
275 let ts = 1615809600; let ds = get_date_str(ts, None, true, false, false, "en");
278 assert_eq!(ds, "Mon Mar 15 2021 12:00:00 +0000");
279 }
280
281 #[test]
282 fn test_isodate_str() {
283 let ts = 1615809600;
284 let ds = get_date_str(ts, None, true, false, true, "en");
285 assert!(ds.contains("2021-03-15"));
286 }
287
288 #[test]
289 fn test_iso_roundtrip() {
290 let ts = 1615809600;
291 let iso = secs_to_iso(ts);
292 let back = iso_to_secs(&iso).unwrap();
293 assert_eq!(ts, back);
294 }
295
296 #[test]
297 fn test_month_from_str() {
298 assert_eq!(month_from_str("Jan"), Some(1));
299 assert_eq!(month_from_str("jan"), Some(1));
300 assert_eq!(month_from_str("Dec"), Some(12));
301 assert_eq!(month_from_str("Foo"), None);
302 }
303
304 #[test]
305 fn test_invalid_date() {
306 assert!(parse_rfc2822_date("").is_err());
307 assert!(parse_rfc2822_date("not a date").is_err());
308 }
309
310 #[test]
311 fn test_localize_date_greek() {
312 let ts = 1615809600; let ds = get_date_str(ts, None, true, false, false, "el");
314 assert!(ds.contains("Δευ"), "Expected Greek Monday abbreviation, got: {}", ds);
315 assert!(ds.contains("Μαρ"), "Expected Greek March abbreviation, got: {}", ds);
316 }
317
318 #[test]
319 fn test_localize_date_german() {
320 let ts = 1615809600;
321 let ds = get_date_str(ts, None, true, false, false, "de");
322 assert!(ds.contains("Mo"), "Expected German Monday abbreviation, got: {}", ds);
323 assert!(ds.contains("Mär"), "Expected German March abbreviation, got: {}", ds);
324 }
325
326 #[test]
327 fn test_localize_date_unknown_lang_falls_back() {
328 let ts = 1615809600;
329 let ds = get_date_str(ts, None, true, false, false, "xx");
330 assert!(ds.contains("Mon"), "Unknown lang should keep English, got: {}", ds);
331 }
332
333 #[test]
334 fn test_parse_gmt_plus_offset() {
335 let ts = parse_rfc2822_date("Mon, 12 Feb 1996 15:24:04 GMT+2");
337 assert!(ts.is_ok(), "GMT+2 should parse successfully, got: {:?}", ts);
338 let t = ts.unwrap();
339 let dt = chrono::Utc.timestamp_opt(t, 0).unwrap();
341 assert_eq!(dt.hour(), 13, "Expected 13:24 UTC, got {:?}", dt);
342 assert_eq!(dt.minute(), 24);
343 }
344
345 #[test]
346 fn test_parse_gmt_minus_offset() {
347 let ts = parse_rfc2822_date("Wed, 01 May 1996 08:00:00 GMT-5");
348 assert!(ts.is_ok(), "GMT-5 should parse, got: {:?}", ts);
349 let t = ts.unwrap();
350 let dt = chrono::Utc.timestamp_opt(t, 0).unwrap();
351 assert_eq!(dt.hour(), 13); }
353
354 #[test]
355 fn test_parse_utc_plus_fractional_offset() {
356 let ts = parse_rfc2822_date("Thu, 01 Jan 1998 12:00:00 UTC+5:30");
357 assert!(ts.is_ok(), "UTC+5:30 should parse, got: {:?}", ts);
358 let t = ts.unwrap();
359 let dt = chrono::Utc.timestamp_opt(t, 0).unwrap();
360 assert_eq!(dt.hour(), 6); assert_eq!(dt.minute(), 30);
362 }
363
364 #[test]
365 fn test_is_leap_year() {
366 assert!(is_leap(2000));
367 assert!(is_leap(2004));
368 assert!(!is_leap(1900));
369 assert!(!is_leap(2001));
370 }
371
372 #[test]
373 fn test_is_leap_before_1752() {
374 assert!(!is_leap(1600));
376 assert!(!is_leap(1752));
377 }
378
379 #[test]
380 fn test_get_timezone_str_format() {
381 let tz = get_timezone_str();
382 assert!(tz.starts_with('+') || tz.starts_with('-'), "Expected +/- prefix, got: {}", tz);
383 assert_eq!(tz.len(), 5, "Expected ±HHMM (5 chars), got: {}", tz);
384 }
385
386 #[test]
387 fn test_eurodate_str() {
388 let ts = 1615809600; let ds = get_date_str(ts, None, true, true, false, "en");
390 assert_eq!(ds, "Mon 15 Mar 2021 12:00:00 +0000");
391 }
392
393 #[test]
394 fn test_custom_format_str() {
395 let ts = 1615809600;
396 let ds = get_date_str(ts, Some("%Y-%m-%d"), true, false, false, "en");
397 assert_eq!(ds, "2021-03-15");
398 }
399}