1use std::fmt;
5
6#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
8pub struct Date {
9 year: i32,
10 month: u8,
11 day: u8,
12}
13
14impl Date {
15 pub fn new(year: i32, month: u8, day: u8) -> Option<Date> {
17 (1..=12).contains(&month).then_some(())?;
18 (day >= 1 && day <= days_in_month(year, month)).then_some(Date { year, month, day })
19 }
20
21 pub fn year(&self) -> i32 {
22 self.year
23 }
24
25 pub fn month(&self) -> u8 {
26 self.month
27 }
28
29 pub fn day(&self) -> u8 {
30 self.day
31 }
32
33 pub fn to_days(&self) -> i64 {
35 let (y, m, d) = (self.year as i64 - i64::from(self.month <= 2), self.month as i64, self.day as i64);
36 let era = y.div_euclid(400);
37 let yoe = y - era * 400;
38 let doy = (153 * (m + if m > 2 { -3 } else { 9 }) + 2) / 5 + d - 1;
39 era * 146_097 + yoe * 365 + yoe / 4 - yoe / 100 + doy - 719_468
40 }
41
42 pub fn from_days(days: i64) -> Option<Date> {
44 let z = days + 719_468;
45 let era = z.div_euclid(146_097);
46 let doe = z - era * 146_097;
47 let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
48 let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
49 let mp = (5 * doy + 2) / 153;
50 let d = (doy - (153 * mp + 2) / 5 + 1) as u8;
51 let m = if mp < 10 { mp + 3 } else { mp - 9 } as u8;
52 let y = yoe + era * 400 + i64::from(m <= 2);
53 Date::new(i32::try_from(y).ok()?, m, d)
54 }
55
56 pub fn today() -> Date {
58 DateTime::now().date
59 }
60
61 pub fn parse_iso(text: &str) -> Option<Date> {
63 let mut parts = text.trim().splitn(3, '-');
64 let y = parts.next()?.parse().ok()?;
65 let m = parts.next()?.parse().ok()?;
66 let d = parts.next()?.parse().ok()?;
67 Date::new(y, m, d)
68 }
69}
70
71impl fmt::Display for Date {
72 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
73 write!(f, "{:04}-{:02}-{:02}", self.year, self.month, self.day)
74 }
75}
76
77pub fn is_leap_year(year: i32) -> bool {
78 (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
79}
80
81pub fn days_in_month(year: i32, month: u8) -> u8 {
82 match month {
83 1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
84 4 | 6 | 9 | 11 => 30,
85 2 if is_leap_year(year) => 29,
86 2 => 28,
87 _ => 0,
88 }
89}
90
91#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
93pub struct Time {
94 hour: u8,
95 minute: u8,
96 second: u8,
97 millisecond: u16,
98}
99
100impl Time {
101 pub fn new(hour: u8, minute: u8, second: u8) -> Option<Time> {
102 Self::with_millis(hour, minute, second, 0)
103 }
104
105 pub fn with_millis(hour: u8, minute: u8, second: u8, millisecond: u16) -> Option<Time> {
106 (hour < 24 && minute < 60 && second < 60 && millisecond < 1000).then_some(Time { hour, minute, second, millisecond })
107 }
108
109 pub fn hour(&self) -> u8 {
110 self.hour
111 }
112
113 pub fn minute(&self) -> u8 {
114 self.minute
115 }
116
117 pub fn second(&self) -> u8 {
118 self.second
119 }
120
121 pub fn millisecond(&self) -> u16 {
122 self.millisecond
123 }
124
125 pub fn parse_iso(text: &str) -> Option<Time> {
127 let mut parts = text.trim().split(':');
128 let h = parts.next()?.parse().ok()?;
129 let m = parts.next()?.parse().ok()?;
130 let (s, ms) = match parts.next() {
131 None => (0, 0),
132 Some(s) => {
133 let (whole, frac) = s.split_once('.').unwrap_or((s, ""));
134 let digits: String = frac.chars().take(3).collect();
136 let ms = if digits.is_empty() { 0 } else { format!("{digits:0<3}").parse().ok()? };
137 (whole.parse().ok()?, ms)
138 }
139 };
140 if parts.next().is_some() {
141 return None;
142 }
143 Time::with_millis(h, m, s, ms)
144 }
145
146 fn seconds_of_day(&self) -> i64 {
147 self.hour as i64 * 3600 + self.minute as i64 * 60 + self.second as i64
148 }
149}
150
151impl fmt::Display for Time {
152 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
153 write!(f, "{:02}:{:02}:{:02}", self.hour, self.minute, self.second)
154 }
155}
156
157#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
159pub struct DateTime {
160 pub date: Date,
161 pub time: Time,
162}
163
164impl DateTime {
165 pub fn new(date: Date, time: Time) -> Self {
166 Self { date, time }
167 }
168
169 pub fn parse_iso(text: &str) -> Option<DateTime> {
173 let text = text.trim();
174 let (d, t) = text.split_once(['T', ' ']).unwrap_or((text, "00:00:00"));
175 let (t, offset) = split_offset(t)?;
176 let local = DateTime { date: Date::parse_iso(d)?, time: Time::parse_iso(t)? };
177 match offset {
178 None => Some(local),
179 Some(offset) => DateTime::from_unix_local(local.to_unix() - offset, local.time.millisecond()),
180 }
181 }
182
183 pub fn to_unix(&self) -> i64 {
185 self.date.to_days() * 86_400 + self.time.seconds_of_day()
186 }
187
188 pub fn from_unix(secs: i64, millisecond: u16) -> Option<DateTime> {
190 let date = Date::from_days(secs.div_euclid(86_400))?;
191 let s = secs.rem_euclid(86_400);
192 let time = Time::with_millis((s / 3600) as u8, (s / 60 % 60) as u8, (s % 60) as u8, millisecond)?;
193 Some(DateTime { date, time })
194 }
195
196 pub fn from_unix_local(utc: i64, millisecond: u16) -> Option<DateTime> {
199 DateTime::from_unix(utc + crate::platform::local_offset(utc), millisecond)
200 }
201
202 pub fn now() -> DateTime {
204 let since = web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).unwrap_or_default();
205 DateTime::from_unix_local(since.as_secs() as i64, since.subsec_millis() as u16).expect("o relógio do sistema dá uma data válida")
206 }
207}
208
209#[doc(hidden)]
212pub fn split_offset(time: &str) -> Option<(&str, Option<i64>)> {
213 if let Some(t) = time.strip_suffix(['Z', 'z']) {
214 return Some((t, Some(0)));
215 }
216 let Some(at) = time.rfind(['+', '-']).filter(|&i| i > 0) else { return Some((time, None)) };
218 let (t, zone) = time.split_at(at);
219 let sign = if zone.starts_with('-') { -1 } else { 1 };
220 let digits: String = zone[1..].chars().filter(|c| *c != ':').collect();
221 let (h, m) = match digits.len() {
222 2 => (digits.parse::<i64>().ok()?, 0),
223 4 => (digits[..2].parse::<i64>().ok()?, digits[2..].parse::<i64>().ok()?),
224 _ => return None,
225 };
226 (h <= 14 && m < 60).then_some((t, Some(sign * (h * 3600 + m * 60))))
227}
228
229impl fmt::Display for DateTime {
230 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
231 write!(f, "{}T{}", self.date, self.time)
232 }
233}