fix(import): address PR #254 review — MacDive XML consumer compatibility

- Align MacDive tank map with UddfEntityImporter: `volume` /
  `workingPressure` keys and `GasMix` object (importer does
  `t['gasMix'] as GasMix?`, so the prior Map would throw a TypeError
  and `volumeL` / `workingPressureBar` were silently dropped).
- Return UTC wall-time from `MacDiveXmlReader._parseDate` so dive
  timestamps don't drift with device timezone / DST, matching the
  Subsurface parser convention.
- Relax MacDive format detection to match `<dives` / `<schema` as
  prefixes so root tags with attributes / namespaces still detect.
- Skip empty `<item/>` gear elements instead of producing a phantom
  `"||"` equipment entity.
- Use `buddyRefs` (resolved via `buddyIdMapping`) instead of
  `unmatchedBuddyNames` so deselected buddies don't get created
  unconditionally — mirrors SubsurfaceXmlParser.

Author: ericgriffin

lib/features/universal_import/data/parsers/macdive_xml_parser.dart

@@ -1,6 +1,8 @@
 import 'dart:convert';
 import 'dart:typed_data';
 
+import 'package:submersion/features/dive_log/domain/entities/dive.dart'
+    show GasMix;
 import 'package:submersion/features/universal_import/data/models/import_enums.dart';
 import 'package:submersion/features/universal_import/data/models/import_options.dart';
 import 'package:submersion/features/universal_import/data/models/import_payload.dart';
@@ -107,22 +109,24 @@ class MacDiveXmlParser implements ImportParser {
       }
 
       if (dive.buddies.isNotEmpty) {
-        final names = <String>[];
+        final buddyRefs = <String>[];
         for (final buddy in dive.buddies) {
           final trimmed = buddy.trim();
           if (trimmed.isEmpty) continue;
-          names.add(trimmed);
+          buddyRefs.add(trimmed);
           buddiesByName.putIfAbsent(
             trimmed,
             () => <String, dynamic>{'name': trimmed, 'uddfId': trimmed},
           );
         }
-        if (names.isNotEmpty) {
-          // `unmatchedBuddyNames` is the key UddfEntityImporter uses for
-          // inline buddy names that should be created on demand and linked
-          // to the dive. This keeps one-pipe compatibility with the UDDF
-          // importer without introducing a second key name.
-          diveMap['unmatchedBuddyNames'] = names;
+        if (buddyRefs.isNotEmpty) {
+          // `buddyRefs` matches the `uddfId` values of the buddy entities we
+          // just added to `buddiesByName`, so `UddfEntityImporter` resolves
+          // them via `buddyIdMapping`. That mapping only has entries for
+          // buddies the user actually selected for import — using
+          // `unmatchedBuddyNames` here would bypass that selection and create
+          // buddies unconditionally. This mirrors SubsurfaceXmlParser.
+          diveMap['buddyRefs'] = buddyRefs;
         }
       }
 
@@ -222,10 +226,12 @@ class MacDiveXmlParser implements ImportParser {
     // MacDive rating is a 0.0-5.0 float; Submersion stores 0-5 int.
     if (d.rating != null) map['rating'] = d.rating!.clamp(0.0, 5.0).round();
 
-    // Tanks: each <gas> becomes a tank map. gasMix is nested as a Map with
-    // o2/he expressed as fractions (0.0-1.0) so the downstream importer can
-    // construct a GasMix and link tank -> gas without having to re-derive
-    // the mix. This mirrors what the UDDF pipeline produces for its tanks.
+    // Tanks: each <gas> becomes a tank map using the same key conventions as
+    // the Subsurface and UDDF parsers so `UddfEntityImporter._buildTanks` can
+    // consume MacDive tanks unchanged — keys `volume` / `workingPressure`
+    // (not `volumeL` / `workingPressureBar`), and `gasMix` as a `GasMix`
+    // object (the importer casts `t['gasMix'] as GasMix?`). `GasMix` stores
+    // o2/he as percentages 0-100, which matches what the reader already emits.
     final tanks = <Map<String, dynamic>>[];
     for (var i = 0; i < d.gases.length; i++) {
       final g = d.gases[i];
@@ -234,17 +240,17 @@ class MacDiveXmlParser implements ImportParser {
         tank['startPressure'] = g.pressureStartBar;
       }
       if (g.pressureEndBar != null) tank['endPressure'] = g.pressureEndBar;
-      if (g.tankSizeLiters != null) tank['volumeL'] = g.tankSizeLiters;
+      if (g.tankSizeLiters != null) tank['volume'] = g.tankSizeLiters;
       if (g.workingPressureBar != null) {
-        tank['workingPressureBar'] = g.workingPressureBar;
+        tank['workingPressure'] = g.workingPressureBar;
       }
       if (g.tankName != null) tank['name'] = g.tankName;
       if (g.supplyType != null) tank['supplyType'] = g.supplyType;
       if (g.duration != null) tank['runtime'] = g.duration;
-      tank['gasMix'] = <String, dynamic>{
-        if (g.oxygenPercent != null) 'o2': g.oxygenPercent! / 100.0,
-        if (g.heliumPercent != null) 'he': g.heliumPercent! / 100.0,
-      };
+      tank['gasMix'] = GasMix(
+        o2: g.oxygenPercent ?? 21.0,
+        he: g.heliumPercent ?? 0.0,
+      );
       tanks.add(tank);
     }
     if (tanks.isNotEmpty) map['tanks'] = tanks;
@@ -292,6 +298,13 @@ class MacDiveXmlParser implements ImportParser {
   }
 
   String _gearKey(MacDiveXmlGearItem g) {
-    return '${g.manufacturer ?? ''}|${g.name ?? ''}|${g.serial ?? ''}';
+    final manufacturer = g.manufacturer?.trim() ?? '';
+    final name = g.name?.trim() ?? '';
+    final serial = g.serial?.trim() ?? '';
+    // Empty `<item/>` elements would otherwise collapse to a `"||"` key and
+    // show up as a phantom equipment entity. Skip them by returning an
+    // empty key; the caller (`_gearKey(...).isEmpty`) drops the item.
+    if (manufacturer.isEmpty && name.isEmpty && serial.isEmpty) return '';
+    return '$manufacturer|$name|$serial';
   }
 }

lib/features/universal_import/data/services/format_detector.dart

@@ -145,9 +145,11 @@ class FormatDetector {
 
     // MacDive native XML: root <dives>, DOCTYPE macdive_logbook.dtd, <schema>.
     // Must precede the UDDF check because both are XML but MacDive's native
-    // XML is a different format entirely.
+    // XML is a different format entirely. Match opening tags as prefixes so
+    // attributes/namespace declarations (`<dives xmlns=...>`) or trailing
+    // whitespace (`<dives >`) don't defeat detection.
     if (lower.contains('mac-dive.com/macdive_logbook.dtd') ||
-        (lower.contains('<dives>') && lower.contains('<schema>'))) {
+        (lower.contains('<dives') && lower.contains('<schema'))) {
       return const DetectionResult(
         format: ImportFormat.macdiveXml,
         sourceApp: SourceApp.macdive,

lib/features/universal_import/data/services/macdive_xml_reader.dart

@@ -208,14 +208,31 @@ class MacDiveXmlReader {
 
   static DateTime? _parseDate(String? raw) {
     if (raw == null || raw.isEmpty) return null;
+    // MacDive XML carries no timezone info — treat the timestamp as a wall
+    // clock and encode it in UTC so dedup and display don't drift when the
+    // device's timezone changes (travel, DST). Matches the Subsurface XML
+    // parser's convention (see SubsurfaceXmlParser._parseDive).
     try {
-      return _dateFormat.parseStrict(raw);
+      return _asUtcWallTime(_dateFormat.parseStrict(raw));
     } catch (_) {
-      // Fallback: ISO-8601 style (2024-06-01T09:00:00)
-      return DateTime.tryParse(raw.replaceFirst(' ', 'T'));
+      final parsed = DateTime.tryParse(raw.replaceFirst(' ', 'T'));
+      return parsed == null ? null : _asUtcWallTime(parsed);
     }
   }
 
+  static DateTime _asUtcWallTime(DateTime value) {
+    return DateTime.utc(
+      value.year,
+      value.month,
+      value.day,
+      value.hour,
+      value.minute,
+      value.second,
+      value.millisecond,
+      value.microsecond,
+    );
+  }
+
   static Duration? _durationSeconds(int? seconds) {
     if (seconds == null) return null;
     return Duration(seconds: seconds);

test/features/universal_import/data/parsers/macdive_xml_parser_test.dart

@@ -4,6 +4,8 @@ import 'dart:typed_data';
 
 import 'package:flutter_test/flutter_test.dart';
 
+import 'package:submersion/features/dive_log/domain/entities/dive.dart'
+    show GasMix;
 import 'package:submersion/features/universal_import/data/models/import_enums.dart';
 import 'package:submersion/features/universal_import/data/models/import_warning.dart';
 import 'package:submersion/features/universal_import/data/parsers/macdive_xml_parser.dart';
@@ -76,10 +78,17 @@ void main() {
       final tank = tanks.first as Map<String, dynamic>;
       expect(tank['startPressure'], 200);
       expect(tank['endPressure'], 60);
-      expect(tank['gasMix'], isNotNull);
-      final gasMix = tank['gasMix'] as Map<String, dynamic>;
-      expect(gasMix['o2'], closeTo(0.32, 0.01));
-      expect(gasMix['he'], closeTo(0.0, 0.01));
+      // Keys match the UDDF/Subsurface tank-map convention so
+      // UddfEntityImporter._buildTanks can consume them directly.
+      expect(tank['volume'], 12);
+      expect(tank['workingPressure'], 232);
+      // gasMix must be a `GasMix` object, not a Map — the importer does
+      // `t['gasMix'] as GasMix?` and a Map cast would throw.
+      expect(tank['gasMix'], isA<GasMix>());
+      final gasMix = tank['gasMix'] as GasMix;
+      // GasMix stores o2/he as percentages 0-100 (not 0-1 fractions).
+      expect(gasMix.o2, closeTo(32.0, 0.01));
+      expect(gasMix.he, closeTo(0.0, 0.01));
     });
 
     test('dive has profile samples with timestamp+depth', () async {
@@ -183,6 +192,30 @@ void main() {
       );
     });
 
+    test(
+      'empty <item/> gear elements are skipped (no phantom entity)',
+      () async {
+        const xml = '''<?xml version="1.0"?>
+<dives><units>Metric</units><schema>2.2.0</schema>
+  <dive>
+    <date>2024-01-01 09:00:00</date><identifier>d1</identifier>
+    <maxDepth>20</maxDepth><duration>1800</duration>
+    <gear>
+      <item/>
+      <item><manufacturer> </manufacturer><name></name><serial/></item>
+      <item><manufacturer>Test</manufacturer><name>BCD1</name></item>
+    </gear>
+    <samples/>
+  </dive>
+</dives>''';
+        final bytes = Uint8List.fromList(utf8.encode(xml));
+        final payload = await const MacDiveXmlParser().parse(bytes);
+        final equipment = payload.entitiesOf(ImportEntityType.equipment);
+        expect(equipment.length, 1, reason: 'only the populated item survives');
+        expect(equipment.first['name'], 'BCD1');
+      },
+    );
+
     test('multiple dives with overlapping buddies dedup', () async {
       const xml = '''<?xml version="1.0"?>
 <dives><units>Metric</units><schema>2.2.0</schema>

test/features/universal_import/data/services/format_detector_test.dart

@@ -151,6 +151,18 @@ void main() {
       final result = detector.detect(Uint8List.fromList(utf8.encode(xml)));
       expect(result.format, isNot(ImportFormat.macdiveXml));
     });
+
+    test('detects MacDive XML when root tags carry attributes', () {
+      const xml =
+          '<?xml version="1.0"?>'
+          '<dives xmlns="http://example.com/mac">'
+          '<schema version="2.2.0">2.2.0</schema>'
+          '<dive/>'
+          '</dives>';
+      final result = detector.detect(Uint8List.fromList(utf8.encode(xml)));
+      expect(result.format, ImportFormat.macdiveXml);
+      expect(result.sourceApp, SourceApp.macdive);
+    });
   });
 
   group('CSV detection', () {

test/features/universal_import/data/services/macdive_xml_reader_test.dart

@@ -25,7 +25,10 @@ void main() {
     test('parses identifier, date, diveNumber', () {
       final dive = MacDiveXmlReader.parse(content).dives.first;
       expect(dive.identifier, '20240601090000-ABC123');
-      expect(dive.date, DateTime(2024, 6, 1, 9, 0, 0));
+      // MacDive XML has no timezone; we encode the wall clock in UTC so
+      // timestamps don't drift across DST or travel. See _parseDate.
+      expect(dive.date, DateTime.utc(2024, 6, 1, 9, 0, 0));
+      expect(dive.date!.isUtc, isTrue);
       expect(dive.diveNumber, 42);
     });