1use std::path::Path;
2
3use serde_json::Value;
4
5use crate::error::MacflyError;
6use crate::html::html_to_clean_text;
7
8#[derive(Debug, Clone, PartialEq, Eq)]
9pub struct ImportedNote {
10 pub title: String,
11 pub body: String,
12 pub folder_override: Option<String>,
13}
14
15#[derive(Debug, Clone, PartialEq, Eq)]
16pub struct ImportedReminder {
17 pub title: String,
18 pub notes: Option<String>,
19 pub list_override: Option<String>,
20}
21
22pub fn is_supported_note_file(path: &Path) -> bool {
24 matches!(
25 path.extension()
26 .and_then(|e| e.to_str())
27 .map(|s| s.to_ascii_lowercase())
28 .as_deref(),
29 Some("md" | "markdown" | "txt" | "html" | "htm" | "json" | "jsonl" | "csv")
30 )
31}
32
33pub fn is_supported_reminder_file(path: &Path) -> bool {
35 matches!(
36 path.extension()
37 .and_then(|e| e.to_str())
38 .map(|s| s.to_ascii_lowercase())
39 .as_deref(),
40 Some("md" | "markdown" | "txt" | "json" | "jsonl" | "csv")
41 )
42}
43
44pub fn parse_notes_from_str(path: &Path, raw: &str) -> Result<Vec<ImportedNote>, MacflyError> {
47 let ext = path
48 .extension()
49 .and_then(|e| e.to_str())
50 .map(|s| s.to_ascii_lowercase())
51 .unwrap_or_default();
52 let fallback_title = path
53 .file_stem()
54 .and_then(|s| s.to_str())
55 .unwrap_or("Imported Note")
56 .to_string();
57
58 match ext.as_str() {
59 "json" => parse_notes_json(raw, &fallback_title),
60 "jsonl" => parse_notes_jsonl(raw, &fallback_title),
61 "csv" => parse_notes_csv(raw),
62 "html" | "htm" => Ok(vec![parse_note_html(raw, &fallback_title)]),
63 _ => Ok(vec![parse_note_markdown(raw, &fallback_title)]),
64 }
65}
66
67pub fn parse_reminders_from_str(
70 path: &Path,
71 raw: &str,
72) -> Result<Vec<ImportedReminder>, MacflyError> {
73 let ext = path
74 .extension()
75 .and_then(|e| e.to_str())
76 .map(|s| s.to_ascii_lowercase())
77 .unwrap_or_default();
78
79 match ext.as_str() {
80 "json" => parse_reminders_json(raw),
81 "jsonl" => parse_reminders_jsonl(raw),
82 "csv" => parse_reminders_csv(raw),
83 "txt" => Ok(parse_reminders_txt(raw)),
84 _ => Ok(parse_reminders_markdown(raw)),
85 }
86}
87
88fn parse_note_markdown(raw: &str, fallback_title: &str) -> ImportedNote {
89 let mut body = raw.trim().to_string();
90 let mut fm_title: Option<String> = None;
91 let mut fm_folder: Option<String> = None;
92
93 if let Some(rest) = body.strip_prefix("---\n")
94 && let Some(end_idx) = rest.find("\n---\n")
95 {
96 let fm = &rest[..end_idx];
97 for line in fm.lines() {
98 if let Some(val) = line.strip_prefix("title:") {
99 let t = unquote(val);
100 if !t.is_empty() {
101 fm_title = Some(t);
102 }
103 } else if let Some(val) = line.strip_prefix("folder:") {
104 let f = unquote(val);
105 if !f.is_empty() {
106 fm_folder = Some(f);
107 }
108 }
109 }
110 body = rest[end_idx + 5..].trim().to_string();
111 }
112
113 if let Some(title) = fm_title {
114 return ImportedNote {
115 title,
116 body,
117 folder_override: fm_folder,
118 };
119 }
120
121 let mut lines = body.lines();
122 if let Some(first) = lines.next()
123 && let Some(heading) = first.strip_prefix("# ")
124 {
125 let title = heading.trim().to_string();
126 let remaining: String = lines.collect::<Vec<_>>().join("\n").trim().to_string();
127 if !title.is_empty() {
128 return ImportedNote {
129 title,
130 body: remaining,
131 folder_override: fm_folder,
132 };
133 }
134 }
135
136 ImportedNote {
137 title: fallback_title.to_string(),
138 body,
139 folder_override: fm_folder,
140 }
141}
142
143fn parse_note_html(raw: &str, fallback_title: &str) -> ImportedNote {
144 let title = extract_html_tag(raw, "title")
145 .or_else(|| extract_html_tag(raw, "h1"))
146 .map(|s| html_to_clean_text(&s))
147 .filter(|s| !s.is_empty())
148 .unwrap_or_else(|| fallback_title.to_string());
149 let body = html_to_clean_text(raw);
150 ImportedNote {
151 title,
152 body,
153 folder_override: None,
154 }
155}
156
157fn extract_html_tag(html: &str, tag: &str) -> Option<String> {
158 let lower = html.to_ascii_lowercase();
159 let open_pat = format!("<{tag}");
160 let close_pat = format!("</{tag}>");
161 let start_tag = lower.find(&open_pat)?;
162 let gt = lower[start_tag..].find('>')? + start_tag + 1;
163 let end_tag = lower[gt..].find(&close_pat)? + gt;
164 Some(html[gt..end_tag].trim().to_string())
165}
166
167fn parse_notes_json(raw: &str, fallback_title: &str) -> Result<Vec<ImportedNote>, MacflyError> {
168 let val: Value = serde_json::from_str(raw)?;
169 match &val {
170 Value::Array(items) => {
171 let mut out = Vec::new();
172 for (idx, item) in items.iter().enumerate() {
173 if let Some(note) = note_from_json_value(item, &format!("{fallback_title} #{}", idx + 1)) {
174 out.push(note);
175 }
176 }
177 Ok(out)
178 }
179 Value::Object(map) => {
180 if let Some(Value::Array(items)) = map.get("notes").or_else(|| map.get("items")) {
181 let mut out = Vec::new();
182 for (idx, item) in items.iter().enumerate() {
183 if let Some(note) =
184 note_from_json_value(item, &format!("{fallback_title} #{}", idx + 1))
185 {
186 out.push(note);
187 }
188 }
189 return Ok(out);
190 }
191 Ok(note_from_json_value(&val, fallback_title)
192 .into_iter()
193 .collect())
194 }
195 _ => Err(MacflyError::PlanError(
196 "JSON-Import erwartet ein Objekt oder ein Array von Notizen".to_string(),
197 )),
198 }
199}
200
201fn parse_notes_jsonl(raw: &str, fallback_title: &str) -> Result<Vec<ImportedNote>, MacflyError> {
202 let mut out = Vec::new();
203 for (idx, line) in raw.lines().enumerate() {
204 let trimmed = line.trim();
205 if trimmed.is_empty() {
206 continue;
207 }
208 let val: Value = serde_json::from_str(trimmed)?;
209 if let Some(note) = note_from_json_value(&val, &format!("{fallback_title} #{}", idx + 1)) {
210 out.push(note);
211 }
212 }
213 Ok(out)
214}
215
216fn note_from_json_value(val: &Value, fallback_title: &str) -> Option<ImportedNote> {
217 let obj = val.as_object()?;
218 let title = pick_str(obj, &["title", "name", "subject", "heading"])
219 .unwrap_or_else(|| fallback_title.to_string());
220 let body = pick_str(
221 obj,
222 &["body", "body_text", "content", "text", "markdown", "note", "description"],
223 )
224 .unwrap_or_default();
225 let folder_override = pick_str(obj, &["folder", "folder_path"]);
226 if title.is_empty() && body.is_empty() {
227 return None;
228 }
229 Some(ImportedNote {
230 title,
231 body,
232 folder_override,
233 })
234}
235
236fn parse_notes_csv(raw: &str) -> Result<Vec<ImportedNote>, MacflyError> {
237 let rows = parse_csv_rows(raw);
238 if rows.len() < 2 {
239 return Ok(Vec::new());
240 }
241 let headers: Vec<String> = rows[0].iter().map(|h| h.trim().to_ascii_lowercase()).collect();
242 let title_idx = find_col(&headers, &["title", "name", "subject", "heading"]).unwrap_or(0);
243 let body_idx = find_col(
244 &headers,
245 &["body", "content", "text", "notes", "note", "description", "markdown"],
246 )
247 .or(if headers.len() > 1 { Some(1) } else { None });
248 let folder_idx = find_col(&headers, &["folder", "folder_path", "category"]);
249
250 let mut out = Vec::new();
251 for row in rows.iter().skip(1) {
252 let title = row
253 .get(title_idx)
254 .map(|s| s.trim().to_string())
255 .unwrap_or_default();
256 let body = body_idx
257 .and_then(|i| row.get(i))
258 .map(|s| s.trim().to_string())
259 .unwrap_or_default();
260 let folder_override = folder_idx
261 .and_then(|i| row.get(i))
262 .map(|s| s.trim().to_string())
263 .filter(|s| !s.is_empty());
264
265 if title.is_empty() && body.is_empty() {
266 continue;
267 }
268 out.push(ImportedNote {
269 title: if title.is_empty() {
270 "Imported Note".to_string()
271 } else {
272 title
273 },
274 body,
275 folder_override,
276 });
277 }
278 Ok(out)
279}
280
281fn parse_reminders_markdown(raw: &str) -> Vec<ImportedReminder> {
282 let mut out = Vec::new();
283 for line in raw.lines() {
284 let trimmed = line.trim();
285 let item = trimmed
286 .strip_prefix("- [ ] ")
287 .or_else(|| trimmed.strip_prefix("* [ ] "));
288 if let Some(task) = item {
289 let title = task.trim();
290 if !title.is_empty() {
291 out.push(ImportedReminder {
292 title: title.to_string(),
293 notes: None,
294 list_override: None,
295 });
296 }
297 }
298 }
299 out
300}
301
302fn parse_reminders_txt(raw: &str) -> Vec<ImportedReminder> {
303 let mut out = Vec::new();
304 for line in raw.lines() {
305 let trimmed = line.trim();
306 if trimmed.is_empty() || trimmed.starts_with('#') {
307 continue;
308 }
309 let clean = trimmed
310 .strip_prefix("- [ ] ")
311 .or_else(|| trimmed.strip_prefix("* [ ] "))
312 .or_else(|| trimmed.strip_prefix("- "))
313 .or_else(|| trimmed.strip_prefix("* "))
314 .unwrap_or(trimmed)
315 .trim();
316 if !clean.is_empty() {
317 out.push(ImportedReminder {
318 title: clean.to_string(),
319 notes: None,
320 list_override: None,
321 });
322 }
323 }
324 out
325}
326
327fn parse_reminders_json(raw: &str) -> Result<Vec<ImportedReminder>, MacflyError> {
328 let val: Value = serde_json::from_str(raw)?;
329 match &val {
330 Value::Array(items) => Ok(items.iter().filter_map(reminder_from_json_value).collect()),
331 Value::Object(map) => {
332 if let Some(Value::Array(items)) = map.get("reminders").or_else(|| map.get("tasks")).or_else(|| map.get("items")) {
333 return Ok(items.iter().filter_map(reminder_from_json_value).collect());
334 }
335 Ok(reminder_from_json_value(&val).into_iter().collect())
336 }
337 _ => Err(MacflyError::PlanError(
338 "JSON-Import für Reminders erwartet ein Array oder Objekt".to_string(),
339 )),
340 }
341}
342
343fn parse_reminders_jsonl(raw: &str) -> Result<Vec<ImportedReminder>, MacflyError> {
344 let mut out = Vec::new();
345 for line in raw.lines() {
346 let trimmed = line.trim();
347 if trimmed.is_empty() {
348 continue;
349 }
350 let val: Value = serde_json::from_str(trimmed)?;
351 if let Some(r) = reminder_from_json_value(&val) {
352 out.push(r);
353 }
354 }
355 Ok(out)
356}
357
358fn reminder_from_json_value(val: &Value) -> Option<ImportedReminder> {
359 if let Some(s) = val.as_str() {
360 let t = s.trim();
361 if t.is_empty() {
362 return None;
363 }
364 return Some(ImportedReminder {
365 title: t.to_string(),
366 notes: None,
367 list_override: None,
368 });
369 }
370 let obj = val.as_object()?;
371 let title = pick_str(obj, &["title", "name", "task", "content", "summary"])?;
372 if title.is_empty() {
373 return None;
374 }
375 let notes = pick_str(obj, &["notes", "body", "description", "comment"]);
376 let list_override = pick_str(obj, &["list", "project", "category"]);
377 Some(ImportedReminder {
378 title,
379 notes,
380 list_override,
381 })
382}
383
384fn parse_reminders_csv(raw: &str) -> Result<Vec<ImportedReminder>, MacflyError> {
385 let rows = parse_csv_rows(raw);
386 if rows.len() < 2 {
387 return Ok(Vec::new());
388 }
389 let headers: Vec<String> = rows[0].iter().map(|h| h.trim().to_ascii_lowercase()).collect();
390 let title_idx = find_col(&headers, &["title", "task", "name", "content", "summary"]).unwrap_or(0);
391 let notes_idx = find_col(&headers, &["notes", "description", "body", "comment"]);
392 let list_idx = find_col(&headers, &["list", "project", "category"]);
393
394 let mut out = Vec::new();
395 for row in rows.iter().skip(1) {
396 let title = row
397 .get(title_idx)
398 .map(|s| s.trim().to_string())
399 .unwrap_or_default();
400 if title.is_empty() {
401 continue;
402 }
403 let notes = notes_idx
404 .and_then(|i| row.get(i))
405 .map(|s| s.trim().to_string())
406 .filter(|s| !s.is_empty());
407 let list_override = list_idx
408 .and_then(|i| row.get(i))
409 .map(|s| s.trim().to_string())
410 .filter(|s| !s.is_empty());
411
412 out.push(ImportedReminder {
413 title,
414 notes,
415 list_override,
416 });
417 }
418 Ok(out)
419}
420
421pub fn parse_csv_rows(input: &str) -> Vec<Vec<String>> {
423 let mut rows = Vec::new();
424 let mut row = Vec::new();
425 let mut field = String::new();
426 let mut in_quotes = false;
427 let mut chars = input.chars().peekable();
428
429 while let Some(c) = chars.next() {
430 if in_quotes {
431 if c == '"' {
432 if chars.peek() == Some(&'"') {
433 chars.next();
434 field.push('"');
435 } else {
436 in_quotes = false;
437 }
438 } else {
439 field.push(c);
440 }
441 } else {
442 match c {
443 '"' => in_quotes = true,
444 ',' => {
445 row.push(std::mem::take(&mut field));
446 }
447 '\r' => {
448 if chars.peek() == Some(&'\n') {
449 chars.next();
450 }
451 row.push(std::mem::take(&mut field));
452 if row.iter().any(|cell| !cell.trim().is_empty()) {
453 rows.push(std::mem::take(&mut row));
454 } else {
455 row.clear();
456 }
457 }
458 '\n' => {
459 row.push(std::mem::take(&mut field));
460 if row.iter().any(|cell| !cell.trim().is_empty()) {
461 rows.push(std::mem::take(&mut row));
462 } else {
463 row.clear();
464 }
465 }
466 _ => field.push(c),
467 }
468 }
469 }
470
471 if !field.is_empty() || !row.is_empty() {
472 row.push(field);
473 if row.iter().any(|cell| !cell.trim().is_empty()) {
474 rows.push(row);
475 }
476 }
477
478 rows
479}
480
481fn find_col(headers: &[String], candidates: &[&str]) -> Option<usize> {
482 for cand in candidates {
483 if let Some(pos) = headers.iter().position(|h| h == cand) {
484 return Some(pos);
485 }
486 }
487 None
488}
489
490fn pick_str(map: &serde_json::Map<String, Value>, keys: &[&str]) -> Option<String> {
491 for k in keys {
492 if let Some(v) = map.get(*k).and_then(Value::as_str) {
493 let trimmed = v.trim();
494 if !trimmed.is_empty() {
495 return Some(trimmed.to_string());
496 }
497 }
498 }
499 None
500}
501
502fn unquote(val: &str) -> String {
503 val.trim().trim_matches('"').trim_matches('\'').trim().to_string()
504}
505
506#[cfg(test)]
507mod tests {
508 use super::*;
509
510 #[test]
511 fn parses_csv_json_jsonl_and_html_notes() {
512 let csv = "title,content,folder\n\"Alpha, 1\",\"Line 1\nLine 2\",10 · Work\nBeta,Hello,\n";
513 let notes = parse_notes_from_str(Path::new("export.csv"), csv).unwrap();
514 assert_eq!(notes.len(), 2);
515 assert_eq!(notes[0].title, "Alpha, 1");
516 assert_eq!(notes[0].body, "Line 1\nLine 2");
517 assert_eq!(notes[0].folder_override.as_deref(), Some("10 · Work"));
518
519 let jsonl = "{\"name\":\"N1\",\"text\":\"B1\"}\n{\"title\":\"N2\",\"body\":\"B2\"}\n";
520 let notes_jl = parse_notes_from_str(Path::new("notes.jsonl"), jsonl).unwrap();
521 assert_eq!(notes_jl.len(), 2);
522 assert_eq!(notes_jl[0].title, "N1");
523 assert_eq!(notes_jl[1].body, "B2");
524
525 let html = "<html><head><title>Evernote Clip</title></head><body><p>Saved paragraph</p></body></html>";
526 let notes_html = parse_notes_from_str(Path::new("clip.html"), html).unwrap();
527 assert_eq!(notes_html[0].title, "Evernote Clip");
528 assert!(notes_html[0].body.contains("Saved paragraph"));
529 }
530
531 #[test]
532 fn parses_csv_and_json_reminders() {
533 let csv = "Task,Description,Project\nSteuererklärung,Q4 Belege,Finanzen\n";
534 let rems = parse_reminders_from_str(Path::new("tasks.csv"), csv).unwrap();
535 assert_eq!(rems.len(), 1);
536 assert_eq!(rems[0].title, "Steuererklärung");
537 assert_eq!(rems[0].notes.as_deref(), Some("Q4 Belege"));
538 assert_eq!(rems[0].list_override.as_deref(), Some("Finanzen"));
539 }
540}