Fix/macdive uddf import (Fixes #28) (#42)

* fix: normalize MacDive UDDF namespace and structural quirks before parsing

MacDive exports declare a default XML namespace on the root element
(xmlns="http://www.streit.cc/uddf/3.2/"), which causes all
findElements() calls in the parser to return empty results since
elements are resolved against that namespace rather than the empty one.

Additionally, MacDive places <country> inside geography/address/country
rather than as a direct child of <site>, and puts <equipmentused> inside
<informationafterdive> rather than <informationbeforedive>.

Adds a UddfNormalizer pre-processing layer that dispatches to dialect-
specific handlers before the existing parser runs. The MacDive handler
strips the namespace declaration, copies <country> up to the <site>
level, and moves <equipmentused> into <informationbeforedive>.

No changes to the core parser. UddfFullImportService.importAllDataFromUddf
is the single integration point, covering all callers automatically.

Adds 25 unit tests covering the normalizer, dialect detection, and
end-to-end field mapping (depth, duration, water temp, notes, profile,
site country, coordinates, weight).

* fix: support MacDive UDDF dialect in import

MacDive exports are valid UDDF 3.2.1 but diverge from the canonical
form the parser expects in several ways:

- Default XML namespace on the root element causes all findElements()
  calls to return empty results. Strip it from the raw string before
  parsing to avoid re-serialisation ambiguity.
- diveduration and divetime values are float strings (e.g. "3494.00")
  which int.tryParse() rejects, leaving runtime empty and collapsing
  all profile waypoint timestamps to 0. Fall back to
  double.tryParse().round() for both fields.
- Site country is nested at geography/address/country instead of being
  a direct child of the site element.
- equipmentused appears inside informationafterdive rather than
  informationbeforedive where the parser reads it.

Adds UddfNormalizer dispatcher and MacDiveDialectNormalizer that
pre-processes the raw XML string before the core parser runs.
25 unit tests cover namespace stripping, structural fixes, and full
end-to-end import of all key fields.

* Fix: wrapped angle brackets with backticks in doc comments

* fix: handle float-string passedtime in MacDive UDDF surface interval parsing

MacDive exports all numeric values as float strings (e.g. "3600.00").
int.tryParse fails on these, silently dropping surface intervals. Apply
the same double.tryParse fallback already used for diveduration and
divetime waypoints.

* refactor: introduce UddfDialect strategy pattern for dialect-aware UDDF normalization

Replace the static MacDiveDialectNormalizer utility class with a proper
strategy pattern based on an abstract UddfDialect base class, per maintainer
feedback on the PR.

Changes:
- Add UddfDialect abstract base class with isMatch() and a default no-op
  normalizeXml() — the single extension point for new dialects
- Replace MacDiveDialectNormalizer with MacDiveDialect extends UddfDialect,
  organised into private _fixEncoding / _fixStructure helpers for readability
- Move float-encoded integer normalisation (e.g. "60.00" -> "60") into
  MacDiveDialect._fixEncoding via regex, removing the need for double-parse
  fallbacks in the parser
- Rewrite UddfNormalizer to iterate a _dialects list, making adding a new
  dialect a one-line registration
- Simplify two int.tryParse fallbacks in UddfFullImportService back to plain
  int.tryParse — the parser is now fully dialect-unaware

The parser no longer contains any dialect-specific logic. A new dialect only
requires extending UddfDialect and adding one entry to _dialects.

Tests: 28 passing (3 new — float encoding, UddfDialect passthrough, negative
isMatch detection)

* fix: Update stale namespace comment

* fix: harden MacDive dialect detection and normalization safety

MacDiveDialect.isMatch previously matched on the UDDF 3.2 namespace
alone, which Submersion and Subsurface also use. Detection now checks
<generator> tag first, rejecting known non-MacDive exporters, and falls
back to structural quirk heuristics only when no generator is present.

Also adds idempotency guards to _fixSiteCountry and _moveEquipmentUsed
to prevent duplicate elements on repeated normalization, and creates
<informationbeforedive> when absent instead of silently skipping the
dive (which would lose equipment/weight data).

Author: steinbil

lib/core/services/export/uddf/dialects/macdive_dialect.dart

@@ -0,0 +1,136 @@
+import 'package:xml/xml.dart';
+
+import 'package:submersion/core/services/export/uddf/uddf_dialect.dart';
+
+/// Normalizes UDDF files exported by MacDive into the canonical form
+/// expected by [UddfFullImportService].
+///
+/// MacDive deviates from the UDDF standard in the following ways:
+///
+/// **Encoding:**
+/// The document root carries a default namespace
+/// (`http://www.streit.cc/uddf/3.2/`) which causes [XmlElement.findElements]
+/// to return empty results. The namespace is stripped before parsing.
+/// MacDive also writes integer-semantics values as float strings (e.g.
+/// `<divetime>60.00</divetime>`), which are normalised to plain integers so
+/// that standard `int.tryParse()` works in the parser.
+///
+/// **Structure:**
+/// 1. Site country is nested at `geography/address/country` instead of
+///    being a direct child of `<site>`.
+/// 2. `<equipmentused>` is in `<informationafterdive>` instead of
+///    `<informationbeforedive>`.
+class MacDiveDialect extends UddfDialect {
+  static const _namespace = 'http://www.streit.cc/uddf/3.2/';
+
+  // Float-encoded integer fields output by MacDive (e.g. "60.00" -> "60").
+  // MacDive serializes all numeric values as floats regardless of semantics.
+  static final _floatIntPattern = RegExp(
+    r'<(divetime|diveduration|divenumber|passedtime|gradientfactorlow|gradientfactorhigh)>(\d+)\.0+</',
+  );
+
+  @override
+  bool isMatch(XmlDocument doc) {
+    if (doc.rootElement.namespaceUri != _namespace) return false;
+
+    // UDDF-compliant exporters include <generator><name> identifying the app
+    // (e.g. Subsurface, divelog_convert). When present, use it as the
+    // authoritative signal to avoid false positives on other apps' exports.
+    final generators = doc.findAllElements('generator');
+    if (generators.isNotEmpty) {
+      return generators.any((gen) {
+        final name = gen.findElements('name').firstOrNull?.innerText ?? '';
+        return name.toLowerCase().contains('macdive');
+      });
+    }
+
+    // No <generator> tag: fall back to structural quirk detection for files
+    // that lack one (e.g. older MacDive versions or hand-edited UDDF).
+    return _hasMacDiveStructuralQuirks(doc);
+  }
+
+  // Returns true when the document exhibits structural deviations unique to
+  // MacDive: country nested under geography/address instead of directly under
+  // site, or equipmentused placed in informationafterdive.
+  bool _hasMacDiveStructuralQuirks(XmlDocument doc) {
+    final hasNestedCountry = doc.findAllElements('site').any((site) {
+      final geo = site.findElements('geography').firstOrNull;
+      if (geo == null) return false;
+      final address = geo.findElements('address').firstOrNull;
+      if (address == null) return false;
+      return address.findElements('country').isNotEmpty;
+    });
+
+    final hasEquipmentInAfter = doc.findAllElements('dive').any((dive) {
+      final after = dive.findElements('informationafterdive').firstOrNull;
+      if (after == null) return false;
+      return after.findElements('equipmentused').isNotEmpty;
+    });
+
+    return hasNestedCountry || hasEquipmentInAfter;
+  }
+
+  @override
+  String normalizeXml(String rawContent) {
+    final encoded = _fixEncoding(rawContent);
+    final doc = XmlDocument.parse(encoded);
+    _fixStructure(doc);
+    return doc.toXmlString();
+  }
+
+  // Strips the default namespace and normalises float-encoded integer values.
+  // Both operations run on the raw string before parsing to avoid
+  // re-serialization side-effects from round-tripping through XmlDocument.
+  String _fixEncoding(String raw) {
+    final withoutNamespace = raw.replaceFirst(' xmlns="$_namespace"', '');
+    return withoutNamespace.replaceAllMapped(
+      _floatIntPattern,
+      (m) => '<${m[1]}>${m[2]}</',
+    );
+  }
+
+  // Corrects element nesting and misplaced elements.
+  void _fixStructure(XmlDocument doc) {
+    _fixSiteCountry(doc);
+    _moveEquipmentUsed(doc);
+  }
+
+  // Copies <country> from geography/address/country to a direct child of
+  // each <site> element, where the parser expects it.
+  void _fixSiteCountry(XmlDocument doc) {
+    for (final site in doc.findAllElements('site')) {
+      final geo = site.findElements('geography').firstOrNull;
+      if (geo == null) continue;
+      final address = geo.findElements('address').firstOrNull;
+      if (address == null) continue;
+      final country = address.findElements('country').firstOrNull;
+      if (country == null) continue;
+      // Skip if <site> already has a direct <country> child (idempotency).
+      final hasDirectCountry = site.children.whereType<XmlElement>().any(
+        (child) => child.name.local == 'country',
+      );
+      if (hasDirectCountry) continue;
+      site.children.add(country.copy());
+    }
+  }
+
+  // Copies <equipmentused> from <informationafterdive> into
+  // <informationbeforedive>, which is where the parser reads it.
+  // Creates <informationbeforedive> if absent so equipment data is not lost.
+  void _moveEquipmentUsed(XmlDocument doc) {
+    for (final dive in doc.findAllElements('dive')) {
+      final after = dive.findElements('informationafterdive').firstOrNull;
+      if (after == null) continue;
+      final equip = after.findElements('equipmentused').firstOrNull;
+      if (equip == null) continue;
+      var before = dive.findElements('informationbeforedive').firstOrNull;
+      if (before == null) {
+        before = XmlElement(XmlName('informationbeforedive'));
+        dive.children.add(before);
+      }
+      // Skip if informationbeforedive already has equipmentused (idempotency).
+      if (before.findElements('equipmentused').isNotEmpty) continue;
+      before.children.add(equip.copy());
+    }
+  }
+}

lib/core/services/export/uddf/uddf_dialect.dart

@@ -0,0 +1,32 @@
+import 'package:xml/xml.dart';
+
+/// Abstract base class for UDDF dialect handlers.
+///
+/// A dialect encapsulates all vendor-specific deviations from the UDDF
+/// standard and normalizes them into the canonical form expected by
+/// [UddfFullImportService] before parsing begins. The parser is fully
+/// dialect-unaware.
+///
+/// Implementors only need to override [isMatch] and [normalizeXml].
+///
+/// To add support for a new dialect:
+///   1. Create a class extending [UddfDialect].
+///   2. Override [isMatch] to detect the dialect's document signature.
+///   3. Override [normalizeXml] to transform the XML into canonical form.
+///   4. Register an instance in [UddfNormalizer._dialects].
+///
+/// Detection ordering in [UddfNormalizer._dialects] matters — more specific
+/// detectors should be listed before more general ones.
+abstract class UddfDialect {
+  /// Returns true when [doc] is an export from the dialect this class handles.
+  bool isMatch(XmlDocument doc);
+
+  /// Transforms [rawContent] into the canonical UDDF form expected by the
+  /// parser. The default implementation returns [rawContent] unchanged.
+  ///
+  /// Implementations typically handle three categories of deviation:
+  ///   - Encoding quirks   (e.g. wrong namespaces, float-encoded integers)
+  ///   - Structural quirks (e.g. misplaced or mis-nested elements)
+  ///   - Missing elements  (e.g. injecting implied defaults as XML nodes)
+  String normalizeXml(String rawContent) => rawContent;
+}

lib/core/services/export/uddf/uddf_full_import_service.dart

@@ -3,6 +3,7 @@ import 'package:xml/xml.dart';
 import 'package:submersion/core/constants/enums.dart' as enums;
 import 'package:submersion/core/services/export/models/uddf_import_result.dart';
 import 'package:submersion/core/services/export/uddf/uddf_import_parsers.dart';
+import 'package:submersion/core/services/export/uddf/uddf_normalizer.dart';
 import 'package:submersion/features/dive_log/domain/entities/dive.dart';
 
 /// Handles comprehensive UDDF import including all application data.
@@ -15,8 +16,9 @@ class UddfFullImportService {
   /// Import ALL application data from UDDF file.
   /// Returns [UddfImportResult] with all parsed data.
   Future<UddfImportResult> importAllDataFromUddf(String uddfContent) async {
-    final document = XmlDocument.parse(uddfContent);
-    // Use rootElement instead of findElements to handle XML namespaces properly
+    final normalized = UddfNormalizer.normalize(uddfContent);
+    final document = XmlDocument.parse(normalized);
+    // Namespace handling is performed by UddfNormalizer before parsing
     final uddfElement = document.rootElement;
     if (uddfElement.name.local != 'uddf') {
       throw const FormatException(

lib/core/services/export/uddf/uddf_normalizer.dart

@@ -0,0 +1,33 @@
+import 'package:xml/xml.dart';
+
+import 'package:submersion/core/services/export/uddf/dialects/macdive_dialect.dart';
+import 'package:submersion/core/services/export/uddf/uddf_dialect.dart';
+
+/// Pre-processes UDDF content by applying whichever [UddfDialect] matches,
+/// returning canonical UDDF that [UddfFullImportService] can parse without
+/// any dialect-specific logic.
+///
+/// To support a new dialect, create a class extending [UddfDialect] and add
+/// an instance to [_dialects]. More specific detectors must come before more
+/// general ones to avoid false positives.
+class UddfNormalizer {
+  const UddfNormalizer._();
+
+  /// Registered dialects in detection order. More specific detectors first.
+  static final List<UddfDialect> _dialects = [
+    MacDiveDialect(),
+    // Add new dialects here (e.g. ShearwaterDialect(), SubsurfaceDialect()).
+  ];
+
+  /// Returns a normalized copy of [content], applying whichever dialect
+  /// matches, or returns [content] unchanged if no dialect matches.
+  static String normalize(String content) {
+    final doc = XmlDocument.parse(content);
+    for (final dialect in _dialects) {
+      if (dialect.isMatch(doc)) {
+        return dialect.normalizeXml(content);
+      }
+    }
+    return content;
+  }
+}