1use crate::models::{HeartRateRecord, SleepRecord, StepRecord, WeightRecord};
2use chrono::{DateTime, FixedOffset, NaiveDateTime, TimeZone};
3use serde::Deserialize;
4
5pub fn clean_csv_content(content: &str) -> String {
7 let mut lines = content.lines();
8 if let Some(first_line) = lines.next() {
9 let stripped = first_line.trim();
10 if stripped.starts_with("com.samsung.health.")
11 || stripped.starts_with("com.samsung.shealth.")
12 {
13 return lines.collect::<Vec<&str>>().join("\n");
14 }
15 }
16 content.to_string()
17}
18
19pub fn parse_time_offset_minutes(offset_str: &str) -> i32 {
21 let s = offset_str.trim();
22 if s.is_empty() {
23 return 0;
24 }
25
26 if let Ok(val) = s.parse::<i32>() {
27 return val;
28 }
29 if let Ok(val) = s.parse::<f64>() {
30 return val as i32;
31 }
32
33 if s.to_uppercase().starts_with("UTC") {
34 let clean = s[3..].trim();
35 if clean.is_empty() {
36 return 0;
37 }
38 let sign = if clean.starts_with('-') { -1 } else { 1 };
39 let numeric_part: String = clean.chars().filter(|c| c.is_ascii_digit()).collect();
40 if numeric_part.len() >= 2 {
41 if let Ok(hours) = numeric_part[0..2].parse::<i32>() {
42 let minutes = if numeric_part.len() >= 4 {
43 numeric_part[2..4].parse::<i32>().unwrap_or(0)
44 } else {
45 0
46 };
47 return sign * (hours * 60 + minutes);
48 }
49 }
50 }
51
52 0
53}
54
55pub fn parse_samsung_datetime(
57 value: &str,
58 offset_minutes: i32,
59) -> Result<DateTime<FixedOffset>, String> {
60 let value = value.trim();
61 let offset = FixedOffset::east_opt(offset_minutes * 60)
62 .ok_or_else(|| format!("Invalid timezone offset: {} minutes", offset_minutes))?;
63
64 if let Ok(val_f) = value.parse::<f64>() {
65 let val_i = val_f as i64;
66 if val_i > 1_000_000_000_000 {
67 let seconds = val_i / 1000;
68 let nanos = (val_i % 1000) * 1_000_000;
69 if let Some(utc_dt) = DateTime::from_timestamp(seconds, nanos as u32) {
70 return Ok(utc_dt.with_timezone(&offset));
71 }
72 } else if val_i > 1_000_000_000 {
73 if let Some(utc_dt) = DateTime::from_timestamp(val_i, 0) {
74 return Ok(utc_dt.with_timezone(&offset));
75 }
76 }
77 }
78
79 let formats = [
80 "%Y-%m-%d %H:%M:%S%.3f",
81 "%Y-%m-%d %H:%M:%S",
82 "%Y-%m-%d %H:%M",
83 "%Y/%m/%d %H:%M:%S",
84 "%Y/%m/%d %H:%M",
85 ];
86
87 for fmt in &formats {
88 if let Ok(naive) = NaiveDateTime::parse_from_str(value, fmt) {
89 if let Some(local_dt) = offset.from_local_datetime(&naive).single() {
90 return Ok(local_dt);
91 } else {
92 return Ok(DateTime::<FixedOffset>::from_naive_utc_and_offset(
93 naive, offset,
94 ));
95 }
96 }
97 }
98
99 if let Ok(dt) = DateTime::parse_from_rfc3339(value) {
100 return Ok(dt.with_timezone(&offset));
101 }
102
103 Err(format!("Could not parse datetime: {}", value))
104}
105
106#[derive(Debug, Deserialize)]
107struct WeightCsvRow {
108 uuid: String,
109 start_time: String,
110 time_offset: Option<String>,
111 weight: f64,
112 body_fat: Option<f64>,
113 muscle_mass: Option<f64>,
114 body_water: Option<f64>,
115 skeletal_muscle: Option<f64>,
116 bmi: f64,
117}
118
119pub fn parse_weight_csv(content: &str) -> Result<Vec<WeightRecord>, String> {
121 let cleaned = clean_csv_content(content);
122 let mut rdr = csv::ReaderBuilder::new()
123 .flexible(true)
124 .trim(csv::Trim::All)
125 .from_reader(cleaned.as_bytes());
126
127 let mut records = Vec::new();
128 for result in rdr.deserialize::<WeightCsvRow>() {
129 let row = result.map_err(|e| format!("CSV deserialize error: {}", e))?;
130 let offset_str = row.time_offset.unwrap_or_default();
131 let offset = parse_time_offset_minutes(&offset_str);
132 let start_datetime = parse_samsung_datetime(&row.start_time, offset)?;
133
134 records.push(WeightRecord {
135 uuid: row.uuid,
136 weight: row.weight,
137 body_fat: row.body_fat,
138 muscle_mass: row.muscle_mass,
139 body_water: row.body_water,
140 skeletal_muscle: row.skeletal_muscle,
141 bmi: row.bmi,
142 start_datetime,
143 });
144 }
145 Ok(records)
146}
147
148#[derive(Debug, Deserialize)]
149struct SleepCsvRow {
150 uuid: String,
151 start_time: String,
152 end_time: String,
153 time_offset: Option<String>,
154 sleep_duration: f64,
155 efficiency: f64,
156 deep_sleep: Option<f64>,
157 rem_sleep: Option<f64>,
158 light_sleep: Option<f64>,
159 wake_up_count: Option<u32>,
160}
161
162pub fn parse_sleep_csv(content: &str) -> Result<Vec<SleepRecord>, String> {
164 let cleaned = clean_csv_content(content);
165 let mut rdr = csv::ReaderBuilder::new()
166 .flexible(true)
167 .trim(csv::Trim::All)
168 .from_reader(cleaned.as_bytes());
169
170 let mut records = Vec::new();
171 for result in rdr.deserialize::<SleepCsvRow>() {
172 let row = result.map_err(|e| format!("CSV deserialize error: {}", e))?;
173 let offset_str = row.time_offset.unwrap_or_default();
174 let offset = parse_time_offset_minutes(&offset_str);
175 let start_datetime = parse_samsung_datetime(&row.start_time, offset)?;
176 let end_datetime = parse_samsung_datetime(&row.end_time, offset)?;
177
178 records.push(SleepRecord {
179 uuid: row.uuid,
180 sleep_duration: row.sleep_duration,
181 efficiency: row.efficiency,
182 deep_sleep: row.deep_sleep,
183 rem_sleep: row.rem_sleep,
184 light_sleep: row.light_sleep,
185 wake_up_count: row.wake_up_count,
186 start_datetime,
187 end_datetime,
188 });
189 }
190 Ok(records)
191}
192
193#[derive(Debug, Deserialize)]
194struct HeartRateCsvRow {
195 uuid: String,
196 start_time: String,
197 time_offset: Option<String>,
198 heart_rate: u32,
199 min: Option<u32>,
200 max: Option<u32>,
201 heart_rate_zone: Option<String>,
202 binning_data: Option<String>,
203}
204
205pub fn parse_heart_rate_csv(content: &str) -> Result<Vec<HeartRateRecord>, String> {
207 let cleaned = clean_csv_content(content);
208 let mut rdr = csv::ReaderBuilder::new()
209 .flexible(true)
210 .trim(csv::Trim::All)
211 .from_reader(cleaned.as_bytes());
212
213 let mut records = Vec::new();
214 for result in rdr.deserialize::<HeartRateCsvRow>() {
215 let row = result.map_err(|e| format!("CSV deserialize error: {}", e))?;
216 let offset_str = row.time_offset.unwrap_or_default();
217 let offset = parse_time_offset_minutes(&offset_str);
218 let start_datetime = parse_samsung_datetime(&row.start_time, offset)?;
219
220 records.push(HeartRateRecord {
221 uuid: row.uuid,
222 heart_rate: row.heart_rate,
223 min: row.min,
224 max: row.max,
225 heart_rate_zone: row.heart_rate_zone,
226 binning_data: row.binning_data,
227 start_datetime,
228 });
229 }
230 Ok(records)
231}
232
233#[derive(Debug, Deserialize)]
234struct StepCsvRow {
235 uuid: String,
236 start_time: String,
237 end_time: String,
238 time_offset: Option<String>,
239 count: u32,
240 calorie: f64,
241 distance: f64,
242}
243
244pub fn parse_steps_csv(content: &str) -> Result<Vec<StepRecord>, String> {
246 let cleaned = clean_csv_content(content);
247 let mut rdr = csv::ReaderBuilder::new()
248 .flexible(true)
249 .trim(csv::Trim::All)
250 .from_reader(cleaned.as_bytes());
251
252 let mut records = Vec::new();
253 for result in rdr.deserialize::<StepCsvRow>() {
254 let row = result.map_err(|e| format!("CSV deserialize error: {}", e))?;
255 let offset_str = row.time_offset.unwrap_or_default();
256 let offset = parse_time_offset_minutes(&offset_str);
257 let start_datetime = parse_samsung_datetime(&row.start_time, offset)?;
258 let end_datetime = parse_samsung_datetime(&row.end_time, offset)?;
259
260 records.push(StepRecord {
261 uuid: row.uuid,
262 count: row.count,
263 calorie: row.calorie,
264 distance: row.distance,
265 start_datetime,
266 end_datetime,
267 });
268 }
269 Ok(records)
270}