1use std::fs;
4use std::path::{Path, PathBuf};
5
6use serde::{Deserialize, Serialize};
7use sha2::{Digest, Sha256};
8use wellfare_core::companion_sync::CompanionHealthBundle;
9use wellfare_core::models::{HeartRateRecord, SleepRecord, StepRecord, WeightRecord};
10use wellfare_core::parser::{
11 parse_heart_rate_csv, parse_sleep_csv, parse_steps_csv, parse_weight_csv,
12};
13use wellfare_core::record::{EpistemicStatus, EvidenceType, RecordEnvelope, SensitivityClass};
14
15use super::api::WebizenHostApi;
16
17const QAPP_HEALTH: &str = "wellfair-health";
18
19#[derive(Debug, Clone)]
20pub struct EnvelopeWithSummary {
21 pub envelope: RecordEnvelope,
22 pub summary: Option<String>,
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
26pub struct SamsungFileReport {
27 pub path: String,
28 pub kind: String,
29 pub records: u32,
30 pub rejected: u32,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
34pub struct SamsungImportReport {
35 pub source: String,
36 pub files: Vec<SamsungFileReport>,
37 pub records_committed: usize,
38 pub records_skipped: usize,
39 pub errors: Vec<String>,
40 #[serde(default, skip_serializing_if = "Option::is_none")]
41 pub checkpoint_hash: Option<String>,
42 #[serde(default, skip_serializing_if = "Option::is_none")]
46 pub q42_artifact_path: Option<String>,
47}
48
49fn content_hash_hex(payload: &str) -> String {
50 hex::encode(Sha256::digest(payload.as_bytes()).as_slice())
51}
52
53fn envelope_from_parts(
54 id: &str,
55 owner_did: &str,
56 author_did: &str,
57 asserted_unix: u32,
58 payload_json: &str,
59) -> RecordEnvelope {
60 RecordEnvelope {
61 id: id.to_string(),
62 owner_did: owner_did.to_string(),
63 author_did: author_did.to_string(),
64 proxy_did: None,
65 epistemic_status: EpistemicStatus::Asserted,
66 evidence_type: EvidenceType::DeviceMeasured,
67 sensitivity: SensitivityClass::Restricted,
68 asserted_time_unix: asserted_unix,
69 asserted_instant: None,
70 valid_time_start_unix: Some(asserted_unix),
71 valid_time_start_instant: None,
72 valid_time_end_unix: None,
73 valid_time_end_instant: None,
74 predecessor_id: None,
75 blob_hash: Some(content_hash_hex(payload_json)),
76 tombstone: false,
77 }
78}
79
80fn weight_envelopes(
81 records: &[WeightRecord],
82 owner: &str,
83 author: &str,
84) -> Vec<EnvelopeWithSummary> {
85 records
86 .iter()
87 .filter_map(|r| {
88 let payload = serde_json::to_string(r).ok()?;
89 let id = format!("urn:wellfair:weight:{}", r.uuid);
90 let unix = r.start_datetime.timestamp().max(0) as u32;
91 let summary = serde_json::json!({
92 "weight_kg": r.weight,
93 "bmi": r.bmi,
94 })
95 .to_string();
96 Some(EnvelopeWithSummary {
97 envelope: envelope_from_parts(&id, owner, author, unix, &payload),
98 summary: Some(summary),
99 })
100 })
101 .collect()
102}
103
104fn sleep_envelopes(records: &[SleepRecord], owner: &str, author: &str) -> Vec<EnvelopeWithSummary> {
105 records
106 .iter()
107 .filter_map(|r| {
108 let payload = serde_json::to_string(r).ok()?;
109 let id = format!("urn:wellfair:sleep:{}", r.uuid);
110 let unix = r.start_datetime.timestamp().max(0) as u32;
111 let summary = serde_json::json!({
112 "duration_min": r.sleep_duration,
113 "efficiency": r.efficiency,
114 "deep_min": r.deep_sleep,
115 "rem_min": r.rem_sleep,
116 "light_min": r.light_sleep,
117 })
118 .to_string();
119 Some(EnvelopeWithSummary {
120 envelope: envelope_from_parts(&id, owner, author, unix, &payload),
121 summary: Some(summary),
122 })
123 })
124 .collect()
125}
126
127fn heart_rate_envelopes(
128 records: &[HeartRateRecord],
129 owner: &str,
130 author: &str,
131) -> Vec<EnvelopeWithSummary> {
132 records
133 .iter()
134 .filter_map(|r| {
135 let payload = serde_json::to_string(r).ok()?;
136 let id = format!("urn:wellfair:heart_rate:{}", r.uuid);
137 let unix = r.start_datetime.timestamp().max(0) as u32;
138 let summary = serde_json::json!({
139 "heart_rate": r.heart_rate,
140 "min": r.min,
141 "max": r.max,
142 })
143 .to_string();
144 Some(EnvelopeWithSummary {
145 envelope: envelope_from_parts(&id, owner, author, unix, &payload),
146 summary: Some(summary),
147 })
148 })
149 .collect()
150}
151
152fn steps_envelopes(records: &[StepRecord], owner: &str, author: &str) -> Vec<EnvelopeWithSummary> {
153 records
154 .iter()
155 .filter_map(|r| {
156 let payload = serde_json::to_string(r).ok()?;
157 let id = format!("urn:wellfair:steps:{}", r.uuid);
158 let unix = r.start_datetime.timestamp().max(0) as u32;
159 let summary = serde_json::json!({
160 "steps": r.count,
161 "distance_m": r.distance,
162 })
163 .to_string();
164 Some(EnvelopeWithSummary {
165 envelope: envelope_from_parts(&id, owner, author, unix, &payload),
166 summary: Some(summary),
167 })
168 })
169 .collect()
170}
171
172#[derive(Debug, Clone, Copy, PartialEq, Eq)]
173pub enum SamsungCsvKind {
174 Weight,
175 Sleep,
176 HeartRate,
177 Steps,
178 Unknown,
179}
180
181fn classify_samsung_csv(name: &str) -> SamsungCsvKind {
182 let lower = name.to_ascii_lowercase();
183 if lower.contains("weight") || lower.contains("body_composition") {
184 SamsungCsvKind::Weight
185 } else if lower.contains("sleep") {
186 SamsungCsvKind::Sleep
187 } else if lower.contains("heart") {
188 SamsungCsvKind::HeartRate
189 } else if lower.contains("step") || lower.contains("walk") {
190 SamsungCsvKind::Steps
191 } else {
192 SamsungCsvKind::Unknown
193 }
194}
195
196fn kind_label(kind: SamsungCsvKind) -> &'static str {
197 match kind {
198 SamsungCsvKind::Weight => "weight",
199 SamsungCsvKind::Sleep => "sleep",
200 SamsungCsvKind::HeartRate => "heart_rate",
201 SamsungCsvKind::Steps => "steps",
202 SamsungCsvKind::Unknown => "unknown",
203 }
204}
205
206pub fn parse_csv_named_content(
208 filename: &str,
209 content: &str,
210 owner_did: &str,
211 author_did: &str,
212) -> Result<(SamsungCsvKind, Vec<EnvelopeWithSummary>, u32), String> {
213 let kind = classify_samsung_csv(filename);
214 match kind {
215 SamsungCsvKind::Weight => {
216 let records = parse_weight_csv(content).map_err(|e| e.to_string())?;
217 Ok((kind, weight_envelopes(&records, owner_did, author_did), 0))
218 }
219 SamsungCsvKind::Sleep => {
220 let records = parse_sleep_csv(content).map_err(|e| e.to_string())?;
221 Ok((kind, sleep_envelopes(&records, owner_did, author_did), 0))
222 }
223 SamsungCsvKind::HeartRate => {
224 let records = parse_heart_rate_csv(content).map_err(|e| e.to_string())?;
225 Ok((
226 kind,
227 heart_rate_envelopes(&records, owner_did, author_did),
228 0,
229 ))
230 }
231 SamsungCsvKind::Steps => {
232 let records = parse_steps_csv(content).map_err(|e| e.to_string())?;
233 Ok((kind, steps_envelopes(&records, owner_did, author_did), 0))
234 }
235 SamsungCsvKind::Unknown => Ok((kind, Vec::new(), 0)),
236 }
237}
238
239fn parse_csv_file(
240 path: &Path,
241 owner_did: &str,
242 author_did: &str,
243) -> Result<(SamsungCsvKind, Vec<EnvelopeWithSummary>, u32), String> {
244 let content = fs::read_to_string(path).map_err(|e| format!("read {}: {e}", path.display()))?;
245 let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
246 parse_csv_named_content(name, &content, owner_did, author_did)
247}
248
249fn commit_envelopes(
250 host: &mut WebizenHostApi,
251 report: &mut SamsungImportReport,
252 path_label: &str,
253 kind: SamsungCsvKind,
254 envelopes: Vec<EnvelopeWithSummary>,
255 rejected: u32,
256) {
257 let mut committed = 0u32;
258 for item in envelopes {
259 match host.submit_record_with_summary(
260 QAPP_HEALTH,
261 item.envelope,
262 &report.source,
263 item.summary,
264 ) {
265 Ok(n) => {
266 report.records_committed += n;
267 committed += 1;
268 }
269 Err(e) => {
270 report.records_skipped += 1;
271 report.errors.push(e);
272 }
273 }
274 }
275 report.files.push(SamsungFileReport {
276 path: path_label.to_string(),
277 kind: kind_label(kind).to_string(),
278 records: committed,
279 rejected,
280 });
281}
282
283pub fn ingest_companion_health_bundle(
285 host: &mut WebizenHostApi,
286 bundle: &CompanionHealthBundle,
287 owner_did: &str,
288 author_did: &str,
289) -> SamsungImportReport {
290 let mut report = SamsungImportReport {
291 source: format!("companion:{}", bundle.device_id),
292 files: Vec::new(),
293 records_committed: 0,
294 records_skipped: 0,
295 errors: Vec::new(),
296 checkpoint_hash: None,
297 q42_artifact_path: None,
298 };
299
300 if let Err(e) = bundle.validate() {
301 report.errors.push(e);
302 return report;
303 }
304
305 for file in &bundle.files {
306 match parse_csv_named_content(&file.filename, &file.csv_content, owner_did, author_did) {
307 Ok((kind, envelopes, rejected)) => {
308 commit_envelopes(host, &mut report, &file.filename, kind, envelopes, rejected);
309 }
310 Err(e) => {
311 report.errors.push(e);
312 report.files.push(SamsungFileReport {
313 path: file.filename.clone(),
314 kind: "error".into(),
315 records: 0,
316 rejected: 1,
317 });
318 }
319 }
320 }
321
322 report
323}
324
325pub fn import_samsung_folder(
327 host: &mut WebizenHostApi,
328 folder: &Path,
329 owner_did: &str,
330 author_did: &str,
331) -> SamsungImportReport {
332 let mut report = SamsungImportReport {
333 source: format!("folder:{}", folder.display()),
334 files: Vec::new(),
335 records_committed: 0,
336 records_skipped: 0,
337 errors: Vec::new(),
338 checkpoint_hash: None,
339 q42_artifact_path: None,
340 };
341
342 if !folder.is_dir() {
343 report
344 .errors
345 .push(format!("Not a directory: {}", folder.display()));
346 return report;
347 }
348
349 let mut csv_paths: Vec<PathBuf> = Vec::new();
350 let entries = match fs::read_dir(folder) {
351 Ok(e) => e,
352 Err(e) => {
353 report.errors.push(format!("read_dir: {e}"));
354 return report;
355 }
356 };
357
358 for entry in entries.filter_map(Result::ok) {
359 let path = entry.path();
360 if path.extension().and_then(|e| e.to_str()) == Some("csv") {
361 csv_paths.push(path);
362 }
363 }
364 csv_paths.sort();
365
366 for path in csv_paths {
367 let label = path.display().to_string();
368 match parse_csv_file(&path, owner_did, author_did) {
369 Ok((kind, envelopes, rejected)) => {
370 commit_envelopes(host, &mut report, &label, kind, envelopes, rejected);
371 }
372 Err(e) => {
373 report.errors.push(e);
374 report.files.push(SamsungFileReport {
375 path: label,
376 kind: "error".into(),
377 records: 0,
378 rejected: 1,
379 });
380 }
381 }
382 }
383
384 report
385}
386
387#[cfg(test)]
388mod tests {
389 use super::*;
390 use std::io::Write;
391 use wellfare_core::companion_sync::{CompanionCsvFile, CompanionHealthBundle};
392
393 #[test]
394 fn classifies_samsung_csv_names() {
395 assert_eq!(
396 classify_samsung_csv("com.samsung.health.weight.20260101.csv"),
397 SamsungCsvKind::Weight
398 );
399 assert_eq!(classify_samsung_csv("sleep.csv"), SamsungCsvKind::Sleep);
400 }
401
402 #[test]
403 fn weight_csv_produces_envelopes() {
404 let dir = tempfile::tempdir().unwrap();
405 let csv = dir.path().join("weight.csv");
406 let mut f = fs::File::create(&csv).unwrap();
407 writeln!(
408 f,
409 "uuid,start_time,end_time,time_offset,weight,body_fat,muscle_mass,body_water,skeletal_muscle,bmi"
410 )
411 .unwrap();
412 writeln!(
413 f,
414 "a1000001-0000-4000-8000-000000000001,1777632000000,1777632060000,60,72.0,18.5,32.1,55.2,30.5,23.1"
415 )
416 .unwrap();
417
418 let (kind, envelopes, _) = parse_csv_file(&csv, "did:wf:owner", "did:wf:owner").unwrap();
419 assert_eq!(kind, SamsungCsvKind::Weight);
420 assert_eq!(envelopes.len(), 1);
421 assert_eq!(
422 envelopes[0].envelope.evidence_type,
423 EvidenceType::DeviceMeasured
424 );
425 }
426
427 #[test]
428 fn companion_bundle_parses_named_content() {
429 let csv = "uuid,start_time,end_time,time_offset,weight,body_fat,muscle_mass,body_water,skeletal_muscle,bmi\n\
430 a1000001-0000-4000-8000-000000000001,1777632000000,1777632060000,60,72.0,18.5,32.1,55.2,30.5,23.1\n";
431 let (kind, envelopes, _) =
432 parse_csv_named_content("weight.csv", csv, "did:wf:owner", "did:wf:owner").unwrap();
433 assert_eq!(kind, SamsungCsvKind::Weight);
434 assert_eq!(envelopes.len(), 1);
435
436 let bundle = CompanionHealthBundle::new(
437 "pixel-test",
438 1_700_000_000,
439 vec![CompanionCsvFile {
440 filename: "weight.csv".into(),
441 csv_content: csv.into(),
442 }],
443 );
444 assert!(bundle.validate().is_ok());
445 }
446}